```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
  var vowels = ["a", "e", "i", "o", "u"]
  var result = ""
  for i in 0..<word.count {
    if vowels.contains(String(word[word.index(word.startIndex, offsetBy: i)])) {
      if i == 0 {
        return ""
      }
      for j in 0..<word.count {
        if vowels.contains(String(word[word.index(word.startIndex, offsetBy: j)])) {
          if j == 0 {
            return ""
          }
          if word[word.index(word.startIndex, offsetBy: j)] == word[word.index(word.startIndex, offsetBy: i - 1)] {
            return ""
          }
          if word[word.index(word.startIndex, offsetBy: j)] == word[word.index(word.startIndex, offsetBy: i + 1)] {
            return ""
          }
          if word[word.index(word.startIndex, offsetBy: j)] == word[word.index(word.startIndex, offsetBy: i)] {
            return ""
          }
          if word[word.index(word.startIndex, offsetBy: j)] == word[word.index(word.startIndex, offsetBy: i - 2)] {
            return ""
          }
          if word[word.index(word.startIndex, offsetBy: j)] == word[word.index(word.startIndex, offsetBy: i + 2)] {
            return ""
          }
          if word[word.index(word.startIndex, offsetBy: j)] == word[word.index(word.startIndex, offsetBy: i - 3)] {
            return ""
          }
          if word[word.index(word.startIndex, offsetBy: j)] == word[word.index(word.startIndex, offsetBy: i + 3)] {
            return ""
          }
          if word[word.index(word.startIndex, offsetBy: j)] == word[word.index(word.startIndex, offsetBy: i - 4)] {
            return ""
          }
          if word[word.index(word.startIndex, offsetBy: j)] == word[word.index(word.startIndex, offsetBy: i + 4)] {
            return ""
          }
          if word[word.index(word.startIndex, offsetBy: j)] == word[word.index(word.startIndex, offsetBy: i - 5)] {
            return ""
          }
          if word[word.index(word.startIndex, offsetBy: j)] == word[word.index(word.startIndex, offsetBy: i + 5)] {
            return ""
          }
          if word[word.index(word.startIndex, offsetBy: j)] == word[word.index(word.startIndex, offsetBy: i - 6)] {
            return ""
          }
          if word[word.index(word.startIndex, offsetBy: j)] == word[word.index(word.startIndex, offsetBy: i + 6)] {
            return ""
          }
          if word[word.index(word.startIndex, offsetBy: j)] == word[word.index(word.startIndex, offsetBy: i - 7)] {
            return ""
          }
          if word[word.index(word.startIndex, offsetBy: j)] == word[word.index(word.startIndex, offsetBy: i + 7)] {
            return ""
          }
          if word[word.index(word.startIndex, offsetBy: j)] == word[word.index(word.startIndex, offsetBy: i - 8)] {
            return ""
          }
          if word[word.index(word.startIndex, offsetBy: j)] == word[word.index(word.startIndex, offsetBy: i + 8)] {
            return ""
          }
          if word[word.index(word.startIndex, offsetBy: j)] == word[word.index(word.startIndex, offsetBy: i - 9)] {
            return ""
          }
          if word[word.index(word.startIndex, offsetBy: j)] == word[word.index(word.startIndex, offsetBy: i + 9)] {
            return ""
          }
          if word[word.index(word.startIndex, offsetBy: j)] == word[word.index(word.startIndex, offsetBy: i - 10)] {

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let word = word.lowercased()
    var index = 0
    for char in word {
        if vowels.contains(String(char)) {
            index = word.index(word.startIndex, offsetBy: word.distance(from: word.startIndex, to: word.index(word.startIndex, offsetBy: index)))
            break
        }
        index += 1
    }
    if index == 0 {
        return ""
    }
    let left = word[word.index(word.startIndex, offsetBy: index - 1)]
    let right = word[word.index(word.startIndex, offsetBy: index)]
    if vowels.contains(String(left)) && vowels.contains(String(right)) {
        return ""
    }
    return String(right)
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let word = word.lowercased()
    var index = 0
    for char in word {
        if vowels.contains(String(char)) {
            index = word.index(word.startIndex, offsetBy: word.distance(from: word.startIndex, to: word.index(word.startIndex, offsetBy: index)))
            break
        }
        index += 1
    }
    if index == 0 {
        return ""
    }
    let left = word[word.index(word.startIndex, offsetBy: index - 1)]
    let right = word[word.index(word.startIndex, offsetBy: index)]
    if vowels.contains(String(left)) && vowels.contains(String(right)) {
        return ""
    }
    return String(right)
}
<|file_separator|>

func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var word = word.lowercased()
    var index = 0
    for char in word {
        if vowels.contains(String(char)) {
            index = word.index(word.startIndex, offsetBy: word.distance(from: word.startIndex, to: word.index(word.startIndex, offsetBy: index)))
            break
        }
        index += 1
    }
    if index == 0 {
        return ""
    }
    var closest = ""
    for char in word {
        if vowels.contains(String(char)) {
            if abs(word.distance(from: word.startIndex, to: word.index(word.startIndex, offsetBy: index))) < abs(word.distance(from: word.startIndex, to: word.index(word.startIndex, offsetBy: closest.count))) {
                closest = String(char)
            }
        }
    }
    return closest
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var word = word.lowercased()
    var index = 0
    for char in word {
        if vowels.contains(String(char)) {
            index = word.index(word.startIndex, offsetBy: word.distance(from: word.startIndex, to: word.index(word.startIndex, offsetBy: index)))
            break
        }
        index += 1
    }
    if index == 0 {
        return ""
    }
    var closest = ""
    for char in word {
        if vowels.contains(String(char)) {
            if abs(word.distance(from: word.startIndex, to: word.index(word.startIndex, offsetBy: index))) < abs(word.distance(from: word.startIndex, to: word.index(word.startIndex, offsetBy: closest.count))) {
                closest = String(char)
            }
        }
    }
    return closest
}
<|file_separator|>

func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    for i in 0..<word.count {
        if vowels.contains(String(word[word.index(word.startIndex, offsetBy: i)])) {
            closestVowel = String(word[word.index(word.startIndex, offsetBy: i)])
            break
        }
    }
    if closestVowel == "" {
        return ""
    }
    for i in 0..<word.count {
        if closestVowel == String(word[word.index(word.startIndex, offsetBy: i)]) {
            return String(word[word.index(word.startIndex, offsetBy: i + 1)])
        }
    }
    return ""
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    for i in 0..<word.count {
        if vowels.contains(String(word[word.index(word.startIndex, offsetBy: i)])) {
            closestVowel = String(word[word.index(word.startIndex, offsetBy: i)])
            break
        }
    }
    if closestVowel == "" {
        return ""
    }
    for i in 0..<word.count {
        if closestVowel == String(word[word.index(word.startIndex, offsetBy: i)]) {
            return String(word[word.index(word.startIndex, offsetBy: i + 1)])
        }
    }
    return ""
}
<|file_separator|>

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let word = word.lowercased()
    let wordArray = Array(word)
    var result = ""
    var index = 0
    for i in 0..<wordArray.count {
        if vowels.contains(String(wordArray[i])) {
            index = i
            break
        }
    }
    if index == 0 {
        return ""
    }
    for i in index..<wordArray.count {
        if vowels.contains(String(wordArray[i])) {
            result = String(wordArray[i])
            break
        }
    }
    return result
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let word = word.lowercased()
    let wordArray = Array(word)
    var result = ""
    var index = 0
    for i in 0..<wordArray.count {
        if vowels.contains(String(wordArray[i])) {
            index = i
            break
        }
    }
    if index == 0 {
        return ""
    }
    for i in index..<wordArray.count {
        if vowels.contains(String(wordArray[i])) {
            result = String(wordArray[i])
            break
        }
    }
    return result
}
<|file_separator|>

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let word = word.lowercased()
    var closest = ""
    for i in 0..<word.count {
        if vowels.contains(String(word[word.index(word.startIndex, offsetBy: i)])) {
            closest = String(word[word.index(word.startIndex, offsetBy: i)])
            break
        }
    }
    if closest == "" {
        return ""
    }
    for i in 0..<word.count {
        if vowels.contains(String(word[word.index(word.startIndex, offsetBy: word.count - 1 - i)])) {
            closest = String(word[word.index(word.startIndex, offsetBy: word.count - 1 - i)])
            break
        }
    }
    return closest
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let word = word.lowercased()
    var closest = ""
    for i in 0..<word.count {
        if vowels.contains(String(word[word.index(word.startIndex, offsetBy: i)])) {
            closest = String(word[word.index(word.startIndex, offsetBy: i)])
            break
        }
    }
    if closest == "" {
        return ""
    }
    for i in 0..<word.count {
        if vowels.contains(String(word[word.index(word.startIndex, offsetBy: word.count - 1 - i)])) {
            closest = String(word[word.index(word.startIndex, offsetBy: word.count - 1 - i)])
            break
        }
    }
    return closest
}
<|file_separator|>

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let word = word.lowercased()
    let vowelsIndex = word.index(word.startIndex, offsetBy: 1)
    let vowelsArray = Array(word)
    var result = ""
    for i in 0..<vowelsArray.count {
        if vowels.contains(String(vowelsArray[vowelsIndex])) {
            result = String(vowelsArray[vowelsIndex])
            break
        }
        vowelsIndex = word.index(vowelsIndex, offsetBy: 1)
    }
    return result
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let word = word.lowercased()
    let vowelsIndex = word.index(word.startIndex, offsetBy: 1)
    let vowelsArray = Array(word)
    var result = ""
    for i in 0..<vowelsArray.count {
        if vowels.contains(String(vowelsArray[vowelsIndex])) {
            result = String(vowelsArray[vowelsIndex])
            break
        }
        vowelsIndex = word.index(vowelsIndex, offsetBy: 1)
    }
    return result
}
<|file_separator|>

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let word = word.lowercased()
    let wordArray = Array(word)
    let lastIndex = wordArray.count - 1
    var closestVowel = ""
    for i in 0...lastIndex {
        if vowels.contains(String(wordArray[i])) {
            closestVowel = String(wordArray[i])
            break
        }
    }
    for i in (0...lastIndex).reversed() {
        if vowels.contains(String(wordArray[i])) {
            closestVowel = String(wordArray[i])
            break
        }
    }
    return closestVowel
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let word = word.lowercased()
    let wordArray = Array(word)
    let lastIndex = wordArray.count - 1
    var closestVowel = ""
    for i in 0...lastIndex {
        if vowels.contains(String(wordArray[i])) {
            closestVowel = String(wordArray[i])
            break
        }
    }
    for i in (0...lastIndex).reversed() {
        if vowels.contains(String(wordArray[i])) {
            closestVowel = String(wordArray[i])
            break
        }
    }
    return closestVowel
}
<|file_separator|>

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    for char in word {
        if vowels.contains(String(char)) {
            closestVowel = String(char)
            break
        }
    }
    for char in word.reversed() {
        if vowels.contains(String(char)) {
            closestVowel = String(char)
            break
        }
    }
    return closestVowel
}

func longestWord(word: String) -> String {
    var longestWord = ""
    var currentWord = ""
    for char in word {
        if char == " " {
            if currentWord.count > longestWord.count {
                longestWord = currentWord
            }
            currentWord = ""
        } else {
            currentWord += String(char)
        }
    }
    if currentWord.count > longestWord.count {
        longestWord = currentWord
    }
    return longestWord
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    for char in word {
        if vowels.contains(String(char)) {
            closestVowel = String(char)
            break
        }
    }
    for char in word.reversed() {
        if vowels.contains(String(char)) {
            closestVowel = String(char)
            break
        }
    }
    return closestVowel
}

// You are given a string. Your task is to find the longest word in the string.
// You may assume that the given string contains English letter only.
// Example:
// longestWord(word: "Hello, world!") == "Hello"
// longestWord(word: "Hello, world!") == "Hello"
// longestWord(word: "Hello, world!") == "Hello"
// longestWord(word: "Hello, world!") == "Hello"
func longestWord(word: String) -> String {
    var longestWord = ""
    var currentWord = ""
    for char in word {
        if char == " " {
            if currentWord.count > longestWord.count {
                longestWord = currentWord
            }
            currentWord = ""
        } else {
            currentWord += String(char)
        }
    }
    if currentWord.count > longestWord.count {
        longestWord = currentWord
    }
    return longestWord
}

// You are given a string. Your task is to find the longest word in the string.
// You may assume that the given string contains English letter only.
// Example:
// longestWord(word: "Hello, world!") == "Hello"
// longestWord(word: "Hello, world!") == "Hello"
// longestWord(word: "Hello, world!") == "Hello"
// longestWord(word: "Hello, world!") == "Hello"
func longestWord(word: String) -> String {
    var longestWord = ""
    var currentWord = ""
    for char in word {
        if char == " " {
            if currentWord.count > longestWord.count {
                longestWord = currentWord
            }
            currentWord = ""
        } else {
            currentWord += String(char)
        }
    }
    if currentWord.count > longestWord.count {
        longestWord = currentWord
    }
    return longestWord
}

// You are given a string. Your task is to find the longest word in the string.
// You may assume that the given string contains English letter only.
// Example:
// longestWord(word: "Hello, world!") == "Hello"
// longestWord(word: "Hello, world!") == "Hello"
// longestWord(word: "Hello, world!") == "Hello"
// longestWord(word: "Hello, world!") == "Hello"
func longestWord(word: String) -> String {
    var longestWord = ""
    var currentWord = ""
    for char in word {
        if char == " " {
            if currentWord.count > longestWord.count {
                longestWord = currentWord
            }
            currentWord = ""
        } else {
            currentWord += String(char)
        }
    }
    if currentWord.count > longestWord.count {
        longestWord = currentWord
    }
    return longestWord
}

// You are given a string. Your task is to find the longest word in the string.
// You may assume that the given string contains English letter only.
// Example:
// longestWord(word: "Hello, world!") == "Hello"
// longestWord(word: "Hello, world!") == "Hello"
// longestWord(word: "Hello, world!") == "Hello"
// longestWord(word: "Hello, world!") == "Hello"
func longestWord(word: String) -> String {
    var longestWord = ""
    var currentWord = ""
    for char in word {
        if char == " " {
            if currentWord.count > longestWord.count {
                longestWord = currentWord
            }
            currentWord = ""
        } else {
            currentWord += String(char)
        }
    }
    if currentWord.count > longestWord.count {
        longestWord = currentWord
    }
    return longestWord
}

// You are given a string. Your task is to find the longest word in the string.

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let word = word.lowercased()
    let lastIndex = word.count - 1
    var index = 0
    var result = ""
    while index < lastIndex {
        if vowels.contains(String(word[word.index(word.startIndex, offsetBy: index)])) {
            if vowels.contains(String(word[word.index(word.startIndex, offsetBy: index + 1)])) {
                index += 1
            } else {
                result = String(word[word.index(word.startIndex, offsetBy: index)])
                break
            }
        } else {
            index += 1
        }
    }
    return result
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let word = word.lowercased()
    let lastIndex = word.count - 1
    var index = 0
    var result = ""
    while index < lastIndex {
        if vowels.contains(String(word[word.index(word.startIndex, offsetBy: index)])) {
            if vowels.contains(String(word[word.index(word.startIndex, offsetBy: index + 1)])) {
                index += 1
            } else {
                result = String(word[word.index(word.startIndex, offsetBy: index)])
                break
            }
        } else {
            index += 1
        }
    }
    return result
}

// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let word = word.lowercased()
    let lastIndex = word.count - 1
    var index = 0
    var result = ""
    while index < lastIndex {
        if vowels.contains(String(word[word.index(word.startIndex, offsetBy: index)])) {
            if vowels.contains(String(word[word.index(word.startIndex, offsetBy: index + 1)])) {
                index += 1
            } else {
                result = String(word[word.index(word.startIndex, offsetBy: index)])
                break
            }
        } else {
            index += 1
        }
    }
    return result
}

// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let word = word.lowercased()
    let lastIndex = word.count - 1
    var index = 0
    var result = ""
    while index < lastIndex {
        if vowels.contains(String(word[word.index(word.startIndex, offsetBy: index)])) {
            if vowels.contains(String(word[word.index(word.startIndex, offsetBy: index + 1)])) {
                index += 1
            } else {
                result = String(word[word.index(word.startIndex, offsetBy: index)])
                break
            }
        } else {
            index += 1
        }
    }
    return result
}

// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var consonantsCount = 0
    var closestVowel: String?
    
    for i in stride(from: word.count - 1, through: 0, by: -1) {
        let character = word[i].lowercased()
        if consonantsCount >= 2 {
            if vowels.contains(character) {
                closestVowel = character
                break
            }
        } else {
            if !vowels.contains(character) {
                consonantsCount += 1
            } else {
                consonantsCount = 0
            }
        }
    }
    
    return closestVowel ?? ""
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<end_of_turn>
<start_of_turn>model
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var consonantsCount = 0
    var closestVowel: String?
    
    for i in stride(from: word.count - 1, through: 0, by: -1) {
        let character = word[i].lowercased()
        if consonantsCount >= 2 {
            if vowels.contains(character) {
                closestVowel = character
                break
            }
        } else {
            if !vowels.contains(character) {
                consonantsCount += 1
            } else {
                consonantsCount = 0
            }
        }
    }
    
    return closestVowel ?? ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var consonants = [Character]()
    var closestVowel: Character?
    
    for (index, character) in word.lowercased().enumerated() {
        if vowels.contains(String(character)) {
            if consonants.count >= 2 {
                closestVowel = character
            }
            consonants.removeAll()
        } else {
            consonants.append(character)
        }
    }
    
    return closestVowel ?? ""
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<end_of_turn>
<start_of_turn>model
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var consonants = [Character]()
    var closestVowel: Character?
    
    for (index, character) in word.lowercased().enumerated() {
        if vowels.contains(String(character)) {
            if consonants.count >= 2 {
                closestVowel = character
            }
            consonants.removeAll()
        } else {
            consonants.append(character)
        }
    }
    
    return closestVowel ?? ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var consonants = [Character]()
    var closestVowel: Character?
    
    for (index, char) in word.lowercased().enumerated() {
        if consonants.isEmpty && vowels.contains(String(char)) {
            continue
        }
        
        if consonants.count == 2 {
            closestVowel = consonants[0]
            break
        }
        
        if consonants.count == 1 && vowels.contains(String(char)) {
            closestVowel = consonants[0]
            break
        }
        
        if consonants.count == 0 && vowels.contains(String(char)) {
            consonants.append(char)
        } else if consonants.count == 1 && !vowels.contains(String(char)) {
            consonants.append(char)
        } else if consonants.count == 2 && vowels.contains(String(char)) {
            break
        }
    }
    
    return closestVowel ?? ""
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<end_of_turn>
<start_of_turn>model
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var consonants = [Character]()
    var closestVowel: Character?
    
    for (index, char) in word.lowercased().enumerated() {
        if consonants.isEmpty && vowels.contains(String(char)) {
            continue
        }
        
        if consonants.count == 2 {
            closestVowel = consonants[0]
            break
        }
        
        if consonants.count == 1 && vowels.contains(String(char)) {
            closestVowel = consonants[0]
            break
        }
        
        if consonants.count == 0 && vowels.contains(String(char)) {
            consonants.append(char)
        } else if consonants.count == 1 && !vowels.contains(String(char)) {
            consonants.append(char)
        } else if consonants.count == 2 && vowels.contains(String(char)) {
            break
        }
    }
    
    return closestVowel ?? ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var consonantsCount = 0
    var closestVowel: String?
    
    for (index, char) in word.lowercased().enumerated() {
        if consonantsCount >= 2 {
            break
        }
        
        if vowels.contains(String(char)) {
            if consonantsCount == 0 {
                consonantsCount += 1
            } else {
                closestVowel = String(char)
                consonantsCount += 2
            }
        } else {
            consonantsCount += 1
        }
    }
    
    return closestVowel ?? ""
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<end_of_turn>
<start_of_turn>model
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var consonantsCount = 0
    var closestVowel: String?
    
    for (index, char) in word.lowercased().enumerated() {
        if consonantsCount >= 2 {
            break
        }
        
        if vowels.contains(String(char)) {
            if consonantsCount == 0 {
                consonantsCount += 1
            } else {
                closestVowel = String(char)
                consonantsCount += 2
            }
        } else {
            consonantsCount += 1
        }
    }
    
    return closestVowel ?? ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let wordArray = Array(word)
    var closestVowel: String = ""
    var foundConsonant: Bool = false
    
    for i in stride(from: wordArray.count - 2, through: 0, by: -1) {
        if vowels.contains(String(wordArray[i])) {
            closestVowel = String(wordArray[i])
            foundConsonant = true
        } else if foundConsonant {
            if vowels.contains(String(wordArray[i])) {
                return closestVowel
            }
        } else {
            if !vowels.contains(String(wordArray[i])) {
                foundConsonant = true
            }
        }
    }
    
    return closestVowel
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<end_of_turn>
<start_of_turn>model
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let wordArray = Array(word)
    var closestVowel: String = ""
    var foundConsonant: Bool = false
    
    for i in stride(from: wordArray.count - 2, through: 0, by: -1) {
        if vowels.contains(String(wordArray[i])) {
            closestVowel = String(wordArray[i])
            foundConsonant = true
        } else if foundConsonant {
            if vowels.contains(String(wordArray[i])) {
                return closestVowel
            }
        } else {
            if !vowels.contains(String(wordArray[i])) {
                foundConsonant = true
            }
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels: Set<Character> = ["a", "e", "i", "o", "u"]
    var consonantsCount = 0
    var closestVowel: Character?
    
    for char in word.reversed() {
        if vowels.contains(char) {
            closestVowel = char
            consonantsCount = 0
        } else {
            consonantsCount += 1
            if consonantsCount >= 2 {
                return String(closestVowel!)
            }
        }
    }
    
    return ""
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<end_of_turn>
<start_of_turn>model
```swift
func getClosestVowel(word: String) -> String {
    let vowels: Set<Character> = ["a", "e", "i", "o", "u"]
    var consonantsCount = 0
    var closestVowel: Character?
    
    for char in word.reversed() {
        if vowels.contains(char) {
            closestVowel = char
            consonantsCount = 0
        } else {
            consonantsCount += 1
            if consonantsCount >= 2 {
                return String(closestVowel!)
            }
        }
    }
    
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let wordArray = Array(word)
    
    for i in stride(from: wordArray.count - 2, through: 0, by: -1) {
        if vowels.contains(String(wordArray[i])) {
            if !vowels.contains(String(wordArray[i + 1])) && !vowels.contains(String(wordArray[i + 2])) {
                return String(wordArray[i])
            }
        }
    }
    
    return ""
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<end_of_turn>
<start_of_turn>model
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let wordArray = Array(word)
    
    for i in stride(from: wordArray.count - 2, through: 0, by: -1) {
        if vowels.contains(String(wordArray[i])) {
            if !vowels.contains(String(wordArray[i + 1])) && !vowels.contains(String(wordArray[i + 2])) {
                return String(wordArray[i])
            }
        }
    }
    
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let wordArray = Array(word)
    
    for i in stride(from: wordArray.count - 2, through: 0, by: -1) {
        if vowels.contains(String(wordArray[i])) {
            if !vowels.contains(String(wordArray[i + 1])) && !vowels.contains(String(wordArray[i + 2])) {
                return String(wordArray[i])
            }
        }
    }
    
    return ""
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<end_of_turn>
<start_of_turn>model
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let wordArray = Array(word)
    
    for i in stride(from: wordArray.count - 2, through: 0, by: -1) {
        if vowels.contains(String(wordArray[i])) {
            if !vowels.contains(String(wordArray[i + 1])) && !vowels.contains(String(wordArray[i + 2])) {
                return String(wordArray[i])
            }
        }
    }
    
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let wordArray = Array(word)
    
    for i in stride(from: wordArray.count - 2, through: 0, by: -1) {
        if vowels.contains(String(wordArray[i])) {
            if !vowels.contains(String(wordArray[i + 1])) && !vowels.contains(String(wordArray[i + 2])) {
                return String(wordArray[i])
            }
        }
    }
    
    return ""
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<end_of_turn>
<start_of_turn>model
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let wordArray = Array(word)
    
    for i in stride(from: wordArray.count - 2, through: 0, by: -1) {
        if vowels.contains(String(wordArray[i])) {
            if !vowels.contains(String(wordArray[i + 1])) && !vowels.contains(String(wordArray[i + 2])) {
                return String(wordArray[i])
            }
        }
    }
    
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let wordArray = Array(word)
    var closestVowel = ""
    var lastConsonantIndex = -1
    
    for (index, letter) in wordArray.enumerated() {
        if vowels.contains(String(letter).lowercased()) {
            if lastConsonantIndex == -1 {
                lastConsonantIndex = index
            } else {
                closestVowel = String(letter)
            }
        } else {
            if lastConsonantIndex != -1 {
                lastConsonantIndex = index
            }
        }
    }
    
    return closestVowel
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<end_of_turn>
<start_of_turn>model
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let wordArray = Array(word)
    var closestVowel = ""
    var lastConsonantIndex = -1
    
    for (index, letter) in wordArray.enumerated() {
        if vowels.contains(String(letter).lowercased()) {
            if lastConsonantIndex == -1 {
                lastConsonantIndex = index
            } else {
                closestVowel = String(letter)
            }
        } else {
            if lastConsonantIndex != -1 {
                lastConsonantIndex = index
            }
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var result = ""
    var minDistance = Int.max
    for i in 0..<word.count {
        if vowels.contains(word[i]) {
            for j in i+1..<word.count {
                if vowels.contains(word[j]) {
                    let distance = j - i
                    if distance < minDistance {
                        minDistance = distance
                        result = String(word[j])
                    }
                }
            }
        }
    }
    return result
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var result = ""
    var minDistance = Int.max
    for i in 0..<word.count {
        if vowels.contains(word[i]) {
            for j in i+1..<word.count {
                if vowels.contains(word[j]) {
                    let distance = j - i
                    if distance < minDistance {
                        minDistance = distance
                        result = String(word[j])
                    }
                }
            }
        }
    }
    return result
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var result = ""
    var minDistance = Int.max
    for i in 0..<word.count {
        if vowels.contains(word[i]) {
            for j in i+1..<word.count {
                if vowels.contains(word[j]) {
                    let distance = abs(i - j)
                    if distance < minDistance {
                        minDistance = distance
                        result = word[j]
                    }
                }
            }
        }
    }
    return result
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var result = ""
    var minDistance = Int.max
    for i in 0..<word.count {
        if vowels.contains(word[i]) {
            for j in i+1..<word.count {
                if vowels.contains(word[j]) {
                    let distance = abs(i - j)
                    if distance < minDistance {
                        minDistance = distance
                        result = word[j]
                    }
                }
            }
        }
    }
    return result
}

func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var result = ""
    var minDistance = Int.max
    for i in 0..<word.count {
        if vowels.contains(word[i]) {
            for j in i+1..<word.count {
                if vowels.contains(word[j]) {
                    let distance = abs(i - j)
                    if distance < minDistance {
                        minDistance = distance
                        result = word[j]
                    }
                }
            }
        }
    }
    return result
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    let consonants = "bcdfghjklmnpqrstvwxyz"
    var closestVowel = ""
    var closestVowelDistance = Int.max
    for i in 0..<word.count {
        if vowels.contains(word[i]) {
            for j in i+1..<word.count {
                if consonants.contains(word[j]) {
                    let distance = abs(i - j)
                    if distance < closestVowelDistance {
                        closestVowelDistance = distance
                        closestVowel = String(word[j])
                    }
                    break
                }
            }
        }
    }
    return closestVowel
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    let consonants = "bcdfghjklmnpqrstvwxyz"
    var closestVowel = ""
    var closestVowelDistance = Int.max
    for i in 0..<word.count {
        if vowels.contains(word[i]) {
            for j in i+1..<word.count {
                if consonants.contains(word[j]) {
                    let distance = abs(i - j)
                    if distance < closestVowelDistance {
                        closestVowelDistance = distance
                        closestVowel = String(word[j])
                    }
                    break
                }
            }
        }
    }
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var result = ""
    var minDistance = Int.max
    for i in 0..<word.count {
        if vowels.contains(word[i]) {
            for j in i+1..<word.count {
                if vowels.contains(word[j]) {
                    let distance = abs(i - j)
                    if distance < minDistance {
                        minDistance = distance
                        result = word[j]
                    }
                }
            }
        }
    }
    return result
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var result = ""
    var minDistance = Int.max
    for i in 0..<word.count {
        if vowels.contains(word[i]) {
            for j in i+1..<word.count {
                if vowels.contains(word[j]) {
                    let distance = abs(i - j)
                    if distance < minDistance {
                        minDistance = distance
                        result = word[j]
                    }
                }
            }
        }
    }
    return result
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var closestVowel = ""
    var closestDistance = Int.max
    for i in 0..<word.count {
        if vowels.contains(word[i]) {
            for j in i+1..<word.count {
                if vowels.contains(word[j]) {
                    let distance = j - i
                    if distance < closestDistance {
                        closestVowel = word[j]
                        closestDistance = distance
                    }
                }
            }
        }
    }
    return closestVowel
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var closestVowel = ""
    var closestDistance = Int.max
    for i in 0..<word.count {
        if vowels.contains(word[i]) {
            for j in i+1..<word.count {
                if vowels.contains(word[j]) {
                    let distance = j - i
                    if distance < closestDistance {
                        closestVowel = word[j]
                        closestDistance = distance
                    }
                }
            }
        }
    }
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var closestVowel = ""
    var closestDistance = Int.max
    for (index, letter) in word.enumerated() {
        if vowels.contains(letter) {
            if index > 0 {
                let distance = abs(index - word.distance(from: word.startIndex, to: word.index(of: letter)))
                if distance < closestDistance {
                    closestVowel = String(letter)
                    closestDistance = distance
                }
            }
        }
    }
    return closestVowel
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var closestVowel = ""
    var closestDistance = Int.max
    for (index, letter) in word.enumerated() {
        if vowels.contains(letter) {
            if index > 0 {
                let distance = abs(index - word.distance(from: word.startIndex, to: word.index(of: letter)))
                if distance < closestDistance {
                    closestVowel = String(letter)
                    closestDistance = distance
                }
            }
        }
    }
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    var vowels = "aeiou"
    var result = ""
    var distance = Int.max
    for i in 0..<word.count {
        if vowels.contains(word[i]) {
            if i < distance {
                distance = i
                result = String(word[i])
            }
        }
    }
    return result
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowels = "aeiou"
    var result = ""
    var distance = Int.max
    for i in 0..<word.count {
        if vowels.contains(word[i]) {
            if i < distance {
                distance = i
                result = String(word[i])
            }
        }
    }
    return result
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var result = ""
    var distance = Int.max
    for i in 0..<word.count {
        if vowels.contains(word[i]) {
            for j in i+1..<word.count {
                if vowels.contains(word[j]) {
                    let newDistance = abs(i - j)
                    if newDistance < distance {
                        distance = newDistance
                        result = word[j]
                    }
                }
            }
        }
    }
    return result
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var result = ""
    var distance = Int.max
    for i in 0..<word.count {
        if vowels.contains(word[i]) {
            for j in i+1..<word.count {
                if vowels.contains(word[j]) {
                    let newDistance = abs(i - j)
                    if newDistance < distance {
                        distance = newDistance
                        result = word[j]
                    }
                }
            }
        }
    }
    return result
}

func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var result = ""
    var distance = Int.max
    for i in 0..<word.count {
        if vowels.contains(word[i]) {
            for j in i+1..<word.count {
                if vowels.contains(word[j]) {
                    let newDistance = abs(i - j)
                    if newDistance < distance {
                        distance = newDistance
                        result = word[j]
                    }
                }
            }
        }
    }
    return result
}

func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var result = ""
    var distance = Int.max
    for i in 0..<word.count {
        if vowels.contains(word[i]) {
            for j in i+1..<word.count {
                if vowels.contains(word[j]) {
                    let newDistance = abs(i - j)
                    if newDistance < distance {
                        distance = newDistance
                        result = word[j]
                    }
                }
            }
        }
    }
    return result
}

func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var result = ""
    var distance = Int.max
    for i in 0..<word.count {
        if vowels.contains(word[i]) {
            for j in i+1..<word.count {
                if vowels.contains(word[j]) {
                    let newDistance = abs(i - j)
                    if newDistance < distance {
                        distance = newDistance
                        result = word[j]
                    }
                }
            }
        }
    }
    return result
}

func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var result = ""
    var distance = Int.max
    for i in 0..<word.count {
        if vowels.contains(word[i]) {
            for j in i+1..<word.count {
                if vowels.contains(word[j]) {
                    let newDistance = abs(i - j)
                    if newDistance < distance {
                        distance = newDistance
                        result = word[j]
                    }
                }
            }
        }
    }
    return result
}

func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var result = ""
    var distance = Int.max
    for i in 0..<word.count {
        if vowels.contains(word[i]) {
            for j in i+1..<word.count {
                if vowels.contains(word[j]) {
                    let newDistance = abs(i - j)
                    if newDistance < distance {
                        distance = newDistance
                        result = word[j]
                    }
                }
            }
        }
    }
    return result
}

func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var result = ""
    var distance = Int.max
    for i in 0..<word.count {
        if vowels.contains(word[i]) {
            for j in i+1..<word.count {
                if vowels.contains(word[j]) {
                    let newDistance = abs(i - j)
                    if newDistance < distance {
                        distance = newDistance
                        result = word[j]
                    }
                }
            }
        }
    }
    return result
}

func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var result = ""
    var distance = Int.max
    for i in 0..<word.count {
        if vowels.contains(word[i]) {
            for j in i+1..<word.count {
                if vowels.contains(word[j]) {
                    let newDistance = abs(i - j)
                    if newDistance < distance {
                        distance

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let word = word.lowercased()
    var result = ""
    for i in 0..<word.count {
        if vowels.contains(String(word[word.index(word.startIndex, offsetBy: i)])) {
            result = String(word[word.index(word.startIndex, offsetBy: i)])
            break
        }
    }
    return result
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let word = word.lowercased()
    var result = ""
    for i in 0..<word.count {
        if vowels.contains(String(word[word.index(word.startIndex, offsetBy: i)])) {
            result = String(word[word.index(word.startIndex, offsetBy: i)])
            break
        }
    }
    return result
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var minDistance = Int.max
    for (index, char) in word.enumerated() {
        if vowels.contains(String(char)) {
            let distance = word.distance(from: word.startIndex, to: word.index(word.startIndex, offsetBy: index))
            if distance < minDistance {
                minDistance = distance
                result = String(char)
            }
        }
    }
    return result
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var minDistance = Int.max
    for (index, char) in word.enumerated() {
        if vowels.contains(String(char)) {
            let distance = word.distance(from: word.startIndex, to: word.index(word.startIndex, offsetBy: index))
            if distance < minDistance {
                minDistance = distance
                result = String(char)
            }
        }
    }
    return result
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel: String?
    for (index, letter) in word.reversed().enumerated() {
        if vowels.contains(String(letter)) {
            closestVowel = String(letter)
            break
        }
    }
    return closestVowel?? ""
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel: String?
    for (index, letter) in word.reversed().enumerated() {
        if vowels.contains(String(letter)) {
            closestVowel = String(letter)
            break
        }
    }
    return closestVowel?? ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var closestVowel: String = ""
    var closestVowelIndex: Int = 0
    var closestVowelDistance: Int = 0
    for (index, char) in word.enumerated() {
        if vowels.contains(char) {
            let distance = word.distance(from: index, to: word.endIndex)
            if closestVowelDistance == 0 || distance < closestVowelDistance {
                closestVowel = String(char)
                closestVowelDistance = distance
                closestVowelIndex = index
            }
        }
    }
    if closestVowelDistance == 0 {
        return ""
    }
    return closestVowel
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var closestVowel: String = ""
    var closestVowelIndex: Int = 0
    var closestVowelDistance: Int = 0
    for (index, char) in word.enumerated() {
        if vowels.contains(char) {
            let distance = word.distance(from: index, to: word.endIndex)
            if closestVowelDistance == 0 || distance < closestVowelDistance {
                closestVowel = String(char)
                closestVowelDistance = distance
                closestVowelIndex = index
            }
        }
    }
    if closestVowelDistance == 0 {
        return ""
    }
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var index = 0
    for char in word.characters {
        if vowels.contains(String(char)) {
            result = String(char)
            break
        }
        index += 1
    }
    if result == "" {
        return ""
    }
    var i = index
    while i >= 0 {
        if vowels.contains(String(word[word.index(word.startIndex, offsetBy: i)])) {
            return String(word[word.index(word.startIndex, offsetBy: i)])
        }
        i -= 1
    }
    return ""
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var index = 0
    for char in word.characters {
        if vowels.contains(String(char)) {
            result = String(char)
            break
        }
        index += 1
    }
    if result == "" {
        return ""
    }
    var i = index
    while i >= 0 {
        if vowels.contains(String(word[word.index(word.startIndex, offsetBy: i)])) {
            return String(word[word.index(word.startIndex, offsetBy: i)])
        }
        i -= 1
    }
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels: [Character] = ["a", "e", "i", "o", "u"]
    var closestVowel: Character?
    var closestDistance = Int.max
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            let distance = word.distance(from: index, to: word.endIndex)
            if distance < closestDistance {
                closestDistance = distance
                closestVowel = character
            }
        }
    }
    return String(closestVowel?? "")
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels: [Character] = ["a", "e", "i", "o", "u"]
    var closestVowel: Character?
    var closestDistance = Int.max
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            let distance = word.distance(from: index, to: word.endIndex)
            if distance < closestDistance {
                closestDistance = distance
                closestVowel = character
            }
        }
    }
    return String(closestVowel?? "")
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let word = word.lowercased()
    var closestVowel = ""
    var closestVowelDistance = Int.max
    for (index, letter) in word.enumerated() {
        if vowels.contains(String(letter)) {
            let distance = word.distance(from: index, to: word.endIndex)
            if distance < closestVowelDistance {
                closestVowel = String(letter)
                closestVowelDistance = distance
            }
        }
    }
    return closestVowel
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let word = word.lowercased()
    var closestVowel = ""
    var closestVowelDistance = Int.max
    for (index, letter) in word.enumerated() {
        if vowels.contains(String(letter)) {
            let distance = word.distance(from: index, to: word.endIndex)
            if distance < closestVowelDistance {
                closestVowel = String(letter)
                closestVowelDistance = distance
            }
        }
    }
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var closestVowelIndex = 0
    var closestVowelDistance = 0
    var vowelIndex = 0
    var vowelDistance = 0
    var consonantIndex = 0
    var consonantDistance = 0
    var consonant = ""
    var vowel = ""
    for letter in word {
        if vowels.contains(String(letter)) {
            vowel = String(letter)
            vowelIndex = word.distance(of: vowel)
            vowelDistance = word.distance(of: closestVowel)
            if vowelIndex > closestVowelIndex {
                closestVowel = vowel
                closestVowelIndex = vowelIndex
                closestVowelDistance = vowelDistance
            }
        } else {
            consonant = String(letter)
            consonantIndex = word.distance(of: consonant)
            consonantDistance = word.distance(of: closestVowel)
            if consonantIndex > closestVowelIndex {
                closestVowel = consonant
                closestVowelIndex = consonantIndex
                closestVowelDistance = consonantDistance
            }
        }
    }
    if closestVowelDistance == 0 {
        return ""
    } else {
        return closestVowel
    }
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var closestVowelIndex = 0
    var closestVowelDistance = 0
    var vowelIndex = 0
    var vowelDistance = 0
    var consonantIndex = 0
    var consonantDistance = 0
    var consonant = ""
    var vowel = ""
    for letter in word {
        if vowels.contains(String(letter)) {
            vowel = String(letter)
            vowelIndex = word.distance(of: vowel)
            vowelDistance = word.distance(of: closestVowel)
            if vowelIndex > closestVowelIndex {
                closestVowel = vowel
                closestVowelIndex = vowelIndex
                closestVowelDistance = vowelDistance
            }
        } else {
            consonant = String(letter)
            consonantIndex = word.distance(of: consonant)
            consonantDistance = word.distance(of: closestVowel)
            if consonantIndex > closestVowelIndex {
                closestVowel = consonant
                closestVowelIndex = consonantIndex
                closestVowelDistance = consonantDistance
            }
        }
    }
    if closestVowelDistance == 0 {
        return ""
    } else {
        return closestVowel
    }
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var closestVowelDistance = Int.max
    for (index, character) in word.enumerated() {
        if vowels.contains(String(character)) {
            let distance = word.distance(from: index, to: word.endIndex)
            if distance < closestVowelDistance {
                closestVowelDistance = distance
                closestVowel = String(character)
            }
        }
    }
    return closestVowel
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var closestVowelDistance = Int.max
    for (index, character) in word.enumerated() {
        if vowels.contains(String(character)) {
            let distance = word.distance(from: index, to: word.endIndex)
            if distance < closestVowelDistance {
                closestVowelDistance = distance
                closestVowel = String(character)
            }
        }
    }
    return closestVowel
}
```

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var closestVowelIndex = 0
    var closestVowelDistance = 0
    var currentVowelDistance = 0
    var currentVowelIndex = 0
    var currentConsonantIndex = 0
    var currentConsonantDistance = 0
    var currentVowel = ""
    var currentConsonant = ""
    var previousConsonant = ""
    var previousVowel = ""
    var previousConsonantIndex = 0
    var previousVowelIndex = 0
    var previousVowelDistance = 0
    var previousConsonantDistance = 0
    var previousVowel = ""
    var previousConsonant = ""
    var previousPreviousConsonant = ""
    var previousPreviousVowel = ""
    var previousPreviousConsonantIndex = 0
    var previousPreviousVowelIndex = 0
    var previousPreviousVowelDistance = 0
    var previousPreviousConsonantDistance = 0
    var previousPreviousVowel = ""
    var previousPreviousConsonant = ""
    var previousPreviousPreviousConsonant = ""
    var previousPreviousPreviousVowel = ""
    var previousPreviousPreviousConsonantIndex = 0
    var previousPreviousPreviousVowelIndex = 0
    var previousPreviousPreviousVowelDistance = 0
    var previousPreviousPreviousConsonantDistance = 0
    var previousPreviousPreviousVowel = ""
    var previousPreviousPreviousConsonant = ""
    var previousPreviousPreviousPreviousConsonant = ""
    var previousPreviousPreviousPreviousVowel = ""
    var previousPreviousPreviousPreviousConsonantIndex = 0
    var previousPreviousPreviousPreviousVowelIndex = 0
    var previousPreviousPreviousPreviousVowelDistance = 0
    var previousPreviousPreviousPreviousConsonantDistance = 0
    var previousPreviousPreviousPreviousVowel = ""
    var previousPreviousPreviousPreviousConsonant = ""
    var previousPreviousPreviousPreviousPreviousConsonant = ""
    var previousPreviousPreviousPreviousPreviousVowel = ""
    var previousPreviousPreviousPreviousPreviousConsonantIndex = 0
    var previousPreviousPreviousPreviousPreviousVowelIndex = 0
    var previousPreviousPreviousPreviousPreviousVowelDistance = 0
    var previousPreviousPreviousPreviousPreviousConsonantDistance = 0
    var previousPreviousPreviousPreviousPreviousVowel = ""
    var previousPreviousPreviousPreviousPreviousConsonant = ""
    var previousPreviousPreviousPreviousPreviousPreviousConsonant = ""
    var previousPreviousPreviousPreviousPreviousPreviousVowel = ""
    var previousPreviousPreviousPreviousPreviousPreviousConsonantIndex = 0
    var previousPreviousPreviousPreviousPreviousPreviousVowelIndex = 0
    var previousPreviousPreviousPreviousPreviousPreviousVowelDistance = 0
    var previousPreviousPreviousPreviousPreviousPreviousConsonantDistance = 0
    var previousPreviousPreviousPreviousPreviousPreviousVowel = ""
    var previousPreviousPreviousPreviousPreviousPreviousConsonant = ""
    var previousPreviousPreviousPreviousPreviousPreviousPreviousConsonant = ""
    var previousPreviousPreviousPreviousPreviousPreviousPreviousVowel = ""
    var previousPreviousPreviousPreviousPreviousPreviousPreviousConsonantIndex = 0
    var previousPreviousPreviousPreviousPreviousPreviousPreviousVowelIndex = 0
    var previousPreviousPreviousPreviousPreviousPreviousPreviousVowelDistance = 0
    var previousPreviousPreviousPreviousPreviousPreviousPreviousConsonantDistance = 0
    var previousPreviousPreviousPreviousPreviousPreviousPreviousVowel = ""
    var previousPreviousPreviousPreviousPreviousPreviousPreviousConsonant = ""
    var previousPreviousPreviousPreviousPreviousPreviousPreviousPreviousConsonant = ""
    var previousPreviousPreviousPreviousPreviousPreviousPreviousPreviousVowel = ""
    var previousPreviousPreviousPreviousPreviousPreviousPreviousPreviousConsonantIndex = 0
    var previousPreviousPreviousPreviousPreviousPreviousPreviousPreviousVowelIndex = 0
    var previousPreviousPreviousPreviousPreviousPreviousPreviousPreviousVowelDistance = 0
    var previousPreviousPreviousPreviousPreviousPreviousPreviousPreviousConsonantDistance = 0
    var previousPreviousPreviousPreviousPreviousPreviousPreviousPreviousVowel = ""
    var previousPreviousPreviousPreviousPreviousPreviousPreviousPreviousConsonant = ""
    var previousPreviousPreviousPreviousPreviousPreviousPreviousPreviousPreviousConsonant = ""
    var previousPreviousPreviousPreviousPreviousPreviousPreviousPreviousPreviousVowel = ""
    var previousPreviousPreviousPreviousPreviousPreviousPreviousPreviousPreviousConsonantIndex = 0
    var previousPreviousPreviousPreviousPreviousPreviousPreviousPreviousPreviousVowelIndex = 0
    var previousPreviousPreviousPreviousPreviousPreviousPreviousPreviousPreviousVowelDistance = 0
    var previousPreviousPreviousPreviousPreviousPreviousPreviousPreviousPreviousConsonantDistance = 0
    var previousPreviousPreviousPreviousPreviousPreviousPreviousPreviousPreviousVowel = ""
    var previousPreviousPreviousPreviousPreviousPreviousPreviousPreviousPreviousConsonant = ""
    var previousPreviousPreviousPreviousPreviousPreviousPreviousPreviousPreviousPreviousConsonant = ""
    var previousPreviousPreviousPreviousPreviousPrevious

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel: String = ""
    var closestVowelIndex: Int = 0
    var closestVowelDistance: Int = 0
    var currentVowelDistance: Int = 0
    var currentVowelIndex: Int = 0
    var currentVowel: String = ""
    var currentConsonant: String = ""
    var currentConsonantIndex: Int = 0
    var currentConsonantDistance: Int = 0
    var consonants: [String] = []
    var vowelsFound: [String] = []
    var consonantsFound: [String] = []
    var vowelsFoundIndexes: [Int] = []
    var consonantsFoundIndexes: [Int] = []
    var vowelsFoundDistances: [Int] = []
    var consonantsFoundDistances: [Int] = []
    var vowelsFoundDistancesSorted: [Int] = []
    var consonantsFoundDistancesSorted: [Int] = []
    var vowelsFoundIndexesSorted: [Int] = []
    var consonantsFoundIndexesSorted: [Int] = []
    var vowelsFound: [String] = []
    var consonantsFound: [String] = []
    var vowelsFoundIndexes: [Int] = []
    var consonantsFoundIndexes: [Int] = []
    var vowelsFoundDistances: [Int] = []
    var consonantsFoundDistances: [Int] = []
    var vowelsFoundDistancesSorted: [Int] = []
    var consonantsFoundDistancesSorted: [Int] = []
    var vowelsFoundIndexesSorted: [Int] = []
    var consonantsFoundIndexesSorted: [Int] = []
    var vowelsFound: [String] = []
    var consonantsFound: [String] = []
    var vowelsFoundIndexes: [Int] = []
    var consonantsFoundIndexes: [Int] = []
    var vowelsFoundDistances: [Int] = []
    var consonantsFoundDistances: [Int] = []
    var vowelsFoundDistancesSorted: [Int] = []
    var consonantsFoundDistancesSorted: [Int] = []
    var vowelsFoundIndexesSorted: [Int] = []
    var consonantsFoundIndexesSorted: [Int] = []
    var vowelsFound: [String] = []
    var consonantsFound: [String] = []
    var vowelsFoundIndexes: [Int] = []
    var consonantsFoundIndexes: [Int] = []
    var vowelsFoundDistances: [Int] = []
    var consonantsFoundDistances: [Int] = []
    var vowelsFoundDistancesSorted: [Int] = []
    var consonantsFoundDistancesSorted: [Int] = []
    var vowelsFoundIndexesSorted: [Int] = []
    var consonantsFoundIndexesSorted: [Int] = []
    var vowelsFound: [String] = []
    var consonantsFound: [String] = []
    var vowelsFoundIndexes: [Int] = []
    var consonantsFoundIndexes: [Int] = []
    var vowelsFoundDistances: [Int] = []
    var consonantsFoundDistances: [Int] = []
    var vowelsFoundDistancesSorted: [Int] = []
    var consonantsFoundDistancesSorted: [Int] = []
    var vowelsFoundIndexesSorted: [Int] = []
    var consonantsFoundIndexesSorted: [Int] = []
    var vowelsFound: [String] = []
    var consonantsFound: [String] = []
    var vowelsFoundIndexes: [Int] = []
    var consonantsFoundIndexes: [Int] = []
    var vowelsFoundDistances: [Int] = []
    var consonantsFoundDistances: [Int] = []
    var vowelsFoundDistancesSorted: [Int] = []
    var consonantsFoundDistancesSorted: [Int] = []
    var vowelsFoundIndexesSorted: [Int] = []
    var consonantsFoundIndexesSorted: [Int] = []
    var vowelsFound: [String] = []
    var consonantsFound: [String] = []
    var vowelsFoundIndexes: [Int] = []
    var consonantsFoundIndexes: [Int] = []
    var vowelsFoundDistances: [Int] = []
    var consonantsFoundDistances: [Int] = []
    var

func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var index = 0
    for i in word.characters.reversed() {
        if vowels.contains(String(i)) {
            result = String(i)
            break
        }
        index += 1
    }
    if result == "" {
        return ""
    }
    var result2 = ""
    for i in word.characters {
        if vowels.contains(String(i)) {
            result2 = String(i)
            break
        }
    }
    if result2 == "" {
        return ""
    }
    if index > result2.characters.count {
        return ""
    }
    return result
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var index = 0
    for i in word.characters.reversed() {
        if vowels.contains(String(i)) {
            result = String(i)
            break
        }
        index += 1
    }
    if result == "" {
        return ""
    }
    var result2 = ""
    for i in word.characters {
        if vowels.contains(String(i)) {
            result2 = String(i)
            break
        }
    }
    if result2 == "" {
        return ""
    }
    if index > result2.characters.count {
        return ""
    }
    return result
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "y"]
    var vowel = ""
    var consonant = ""
    for letter in word.reversed() {
        if vowels.contains(String(letter)) {
            vowel = String(letter)
            break
        } else {
            consonant = String(letter)
        }
    }
    return vowel
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "y"]
    var vowel = ""
    var consonant = ""
    for letter in word.reversed() {
        if vowels.contains(String(letter)) {
            vowel = String(letter)
            break
        } else {
            consonant = String(letter)
        }
    }
    return vowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "y"]
    var result = ""
    var vowelIndex = -1
    var consonantIndex = -1
    for (index, char) in word.lowercased().reversed().enumerated() {
        if vowels.contains(String(char)) {
            vowelIndex = index
        } else {
            consonantIndex = index
        }
        if vowelIndex!= -1 && consonantIndex!= -1 {
            result = String(word[word.index(word.endIndex, offsetBy: -1 - vowelIndex)...word.index(word.endIndex, offsetBy: -1 - consonantIndex)])
            break
        }
    }
    return result
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "y"]
    var result = ""
    var vowelIndex = -1
    var consonantIndex = -1
    for (index, char) in word.lowercased().reversed().enumerated() {
        if vowels.contains(String(char)) {
            vowelIndex = index
        } else {
            consonantIndex = index
        }
        if vowelIndex!= -1 && consonantIndex!= -1 {
            result = String(word[word.index(word.endIndex, offsetBy: -1 - vowelIndex)...word.index(word.endIndex, offsetBy: -1 - consonantIndex)])
            break
        }
    }
    return result
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "y"]
    let wordArray = Array(word)
    var result = ""
    var vowelIndex = 0
    var consonantIndex = 0
    var vowelFound = false
    var consonantFound = false
    var i = wordArray.count - 1
    while i >= 0 {
        if vowels.contains(String(wordArray[i])) {
            vowelFound = true
            vowelIndex = i
        } else if vowelFound &&!consonantFound {
            consonantFound = true
            consonantIndex = i
        }
        if vowelFound && consonantFound {
            break
        }
        i -= 1
    }
    if vowelFound && consonantFound {
        result = String(wordArray[vowelIndex])
    }
    return result
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "y"]
    let wordArray = Array(word)
    var result = ""
    var vowelIndex = 0
    var consonantIndex = 0
    var vowelFound = false
    var consonantFound = false
    var i = wordArray.count - 1
    while i >= 0 {
        if vowels.contains(String(wordArray[i])) {
            vowelFound = true
            vowelIndex = i
        } else if vowelFound &&!consonantFound {
            consonantFound = true
            consonantIndex = i
        }
        if vowelFound && consonantFound {
            break
        }
        i -= 1
    }
    if vowelFound && consonantFound {
        result = String(wordArray[vowelIndex])
    }
    return result
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "y"]
    let wordArray = Array(word)
    var vowelIndex = -1
    var consonantIndex = -1
    for i in 0..<wordArray.count {
        if vowels.contains(String(wordArray[i])) {
            vowelIndex = i
        } else {
            consonantIndex = i
        }
        if vowelIndex!= -1 && consonantIndex!= -1 {
            return String(wordArray[vowelIndex])
        }
    }
    return ""
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "y"]
    let wordArray = Array(word)
    var vowelIndex = -1
    var consonantIndex = -1
    for i in 0..<wordArray.count {
        if vowels.contains(String(wordArray[i])) {
            vowelIndex = i
        } else {
            consonantIndex = i
        }
        if vowelIndex!= -1 && consonantIndex!= -1 {
            return String(wordArray[vowelIndex])
        }
    }
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var vowelFound = false
    var consonantFound = false
    for char in word.reversed() {
        let char = String(char)
        if vowels.contains(char) {
            vowelFound = true
            if consonantFound {
                closestVowel = char
                break
            }
        } else {
            consonantFound = true
            if vowelFound {
                break
            }
        }
    }
    return closestVowel
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var vowelFound = false
    var consonantFound = false
    for char in word.reversed() {
        let char = String(char)
        if vowels.contains(char) {
            vowelFound = true
            if consonantFound {
                closestVowel = char
                break
            }
        } else {
            consonantFound = true
            if vowelFound {
                break
            }
        }
    }
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var consonants = [String]()
    var vowelIndex = 0
    var consonantIndex = 0
    for letter in word {
        if vowels.contains(String(letter)) {
            vowelIndex += 1
        } else {
            consonants.append(String(letter))
            consonantIndex += 1
        }
    }
    if consonants.count < 2 {
        return ""
    }
    for i in 0..<consonants.count - 1 {
        if vowels.contains(consonants[i]) {
            closestVowel = consonants[i]
        }
    }
    return closestVowel
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var consonants = [String]()
    var vowelIndex = 0
    var consonantIndex = 0
    for letter in word {
        if vowels.contains(String(letter)) {
            vowelIndex += 1
        } else {
            consonants.append(String(letter))
            consonantIndex += 1
        }
    }
    if consonants.count < 2 {
        return ""
    }
    for i in 0..<consonants.count - 1 {
        if vowels.contains(consonants[i]) {
            closestVowel = consonants[i]
        }
    }
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var lastVowelIndex = -1
    for (index, char) in word.lowercased().reversed().enumerated() {
        if vowels.contains(String(char)) {
            lastVowelIndex = index
            break
        }
    }
    if lastVowelIndex == -1 {
        return ""
    }
    for (index, char) in word.lowercased().reversed().enumerated() {
        if index > lastVowelIndex {
            break
        }
        if vowels.contains(String(char)) {
            closestVowel = String(char)
            break
        }
    }
    return closestVowel
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var lastVowelIndex = -1
    for (index, char) in word.lowercased().reversed().enumerated() {
        if vowels.contains(String(char)) {
            lastVowelIndex = index
            break
        }
    }
    if lastVowelIndex == -1 {
        return ""
    }
    for (index, char) in word.lowercased().reversed().enumerated() {
        if index > lastVowelIndex {
            break
        }
        if vowels.contains(String(char)) {
            closestVowel = String(char)
            break
        }
    }
    return closestVowel
}
```

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var closestVowel = ""
    var vowelIndex = 0
    var consonantIndex = 0
    var consonant = ""
    var vowel = ""
    var consonantFound = false
    var vowelFound = false
    var vowelFoundIndex = 0
    var consonantFoundIndex = 0
    var consonantFoundIndex2 = 0
    var vowelFoundIndex2 = 0
    var closestVowelIndex = 0
    var closestVowelIndex2 = 0
    var closestVowelIndex3 = 0
    var closestVowelIndex4 = 0
    var closestVowelIndex5 = 0
    var closestVowelIndex6 = 0
    var closestVowelIndex7 = 0
    var closestVowelIndex8 = 0
    var closestVowelIndex9 = 0
    var closestVowelIndex10 = 0
    var closestVowelIndex11 = 0
    var closestVowelIndex12 = 0
    var closestVowelIndex13 = 0
    var closestVowelIndex14 = 0
    var closestVowelIndex15 = 0
    var closestVowelIndex16 = 0
    var closestVowelIndex17 = 0
    var closestVowelIndex18 = 0
    var closestVowelIndex19 = 0
    var closestVowelIndex20 = 0
    var closestVowelIndex21 = 0
    var closestVowelIndex22 = 0
    var closestVowelIndex23 = 0
    var closestVowelIndex24 = 0
    var closestVowelIndex25 = 0
    var closestVowelIndex26 = 0
    var closestVowelIndex27 = 0
    var closestVowelIndex28 = 0
    var closestVowelIndex29 = 0
    var closestVowelIndex30 = 0
    var closestVowelIndex31 = 0
    var closestVowelIndex32 = 0
    var closestVowelIndex33 = 0
    var closestVowelIndex34 = 0
    var closestVowelIndex35 = 0
    var closestVowelIndex36 = 0
    var closestVowelIndex37 = 0
    var closestVowelIndex38 = 0
    var closestVowelIndex39 = 0
    var closestVowelIndex40 = 0
    var closestVowelIndex41 = 0
    var closestVowelIndex42 = 0
    var closestVowelIndex43 = 0
    var closestVowelIndex44 = 0
    var closestVowelIndex45 = 0
    var closestVowelIndex46 = 0
    var closestVowelIndex47 = 0
    var closestVowelIndex48 = 0
    var closestVowelIndex49 = 0
    var closestVowelIndex50 = 0
    var closestVowelIndex51 = 0
    var closestVowelIndex52 = 0
    var closestVowelIndex53 = 0
    var closestVowelIndex54 = 0
    var closestVowelIndex55 = 0
    var closestVowelIndex56 = 0
    var closestVowelIndex57 = 0
    var closestVowelIndex58 = 0
    var closestVowelIndex59 = 0
    var closestVowelIndex60 = 0
    var closestVowelIndex61 = 0
    var closestVowelIndex62 = 0
    var closestVowelIndex63 = 0
    var closestVowelIndex64 = 0
    var closestVowelIndex65 = 0
    var closestVowelIndex66 = 0
    var closestVowelIndex67 = 0
    var closestVowelIndex68 = 0
    var closestVowelIndex69 = 0
    var closestVowelIndex70 = 0
    var closestVowelIndex71 = 0
    var closestVowelIndex72 = 0
    var closestVowelIndex73 = 0
    var closestVowelIndex74 = 0
    var closestVowelIndex75 = 0
    var closestVowelIndex76 = 0
    var closestVowelIndex77 = 0
    var closestVowelIndex78 = 0
    var closestVowelIndex79 = 0
    var closestVowelIndex80 = 0
    var closestVowelIndex81 = 0
    var closestVowelIndex82 = 0
    var closestVowelIndex83 = 0
    var closestVowelIndex84 = 0
    var closestVowelIndex85

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "y"]
    var closestVowel = ""
    var closestVowelIndex = 0
    var consonants = 0
    var vowelIndex = 0
    for (index, char) in word.lowercased().reversed().enumerated() {
        if vowels.contains(String(char)) {
            vowelIndex = index
            break
        }
    }
    for (index, char) in word.lowercased().reversed().enumerated() {
        if vowels.contains(String(char)) {
            closestVowelIndex = index
            closestVowel = String(char)
            break
        } else {
            consonants += 1
        }
    }
    if consonants == 0 || vowelIndex == 0 {
        return ""
    } else {
        return closestVowel
    }
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "y"]
    var closestVowel = ""
    var closestVowelIndex = 0
    var consonants = 0
    var vowelIndex = 0
    for (index, char) in word.lowercased().reversed().enumerated() {
        if vowels.contains(String(char)) {
            vowelIndex = index
            break
        }
    }
    for (index, char) in word.lowercased().reversed().enumerated() {
        if vowels.contains(String(char)) {
            closestVowelIndex = index
            closestVowel = String(char)
            break
        } else {
            consonants += 1
        }
    }
    if consonants == 0 || vowelIndex == 0 {
        return ""
    } else {
        return closestVowel
    }
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var closestVowel = ""
    var vowelFound = false
    for char in word.reversed() {
        if vowels.contains(char) {
            vowelFound = true
            closestVowel = String(char)
        } else if vowelFound {
            return closestVowel
        }
    }
    return ""
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var closestVowel = ""
    var vowelFound = false
    for char in word.reversed() {
        if vowels.contains(char) {
            vowelFound = true
            closestVowel = String(char)
        } else if vowelFound {
            return closestVowel
        }
    }
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var result = ""
    var index = 0
    while index < word.count {
        if consonants.contains(String(word[index])) {
            index += 1
            continue
        }
        let vowels = ["a", "e", "i", "o", "u"]
        for vowel in vowels {
            let vowelIndex = word.index(word.startIndex, offsetBy: index, limitedBy: word.endIndex)!
            if String(word[vowelIndex]) == vowel {
                result = vowel
                break
            }
        }
        break
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var result = ""
    var index = 0
    while index < word.count {
        if consonants.contains(String(word[index])) {
            index += 1
            continue
        }
        let vowels = ["a", "e", "i", "o", "u"]
        for vowel in vowels {
            let vowelIndex = word.index(word.startIndex, offsetBy: index, limitedBy: word.endIndex)!
            if String(word[vowelIndex]) == vowel {
                result = vowel
                break
            }
        }
        break
    }
    return result
}
```

func getClosestVowel(word: String) -> String {
    guard word.count > 1 else {
        return ""
    }
    
    let consonants = word.filter {!$0.isVowel }
    let consonantsCount = consonants.count
    
    guard consonantsCount > 0 else {
        return ""
    }
    
    let lastConsonant = consonants[consonantsCount - 1]
    let lastConsonantIndex = word.firstIndex(of: lastConsonant)!
    
    let vowels = word.filter { $0.isVowel }
    let vowelsCount = vowels.count
    
    guard vowelsCount > 0 else {
        return ""
    }
    
    let firstVowel = vowels[0]
    let firstVowelIndex = word.firstIndex(of: firstVowel)!
    
    let firstVowelDistance = lastConsonantIndex - firstVowelIndex
    let lastVowelDistance = word.count - lastConsonantIndex - 1
    
    let closestVowelDistance = min(firstVowelDistance, lastVowelDistance)
    
    let closestVowel = vowels[closestVowelDistance]
    
    return closestVowel
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    guard word.count > 1 else {
        return ""
    }
    
    let consonants = word.filter {!$0.isVowel }
    let consonantsCount = consonants.count
    
    guard consonantsCount > 0 else {
        return ""
    }
    
    let lastConsonant = consonants[consonantsCount - 1]
    let lastConsonantIndex = word.firstIndex(of: lastConsonant)!
    
    let vowels = word.filter { $0.isVowel }
    let vowelsCount = vowels.count
    
    guard vowelsCount > 0 else {
        return ""
    }
    
    let firstVowel = vowels[0]
    let firstVowelIndex = word.firstIndex(of: firstVowel)!
    
    let firstVowelDistance = lastConsonantIndex - firstVowelIndex
    let lastVowelDistance = word.count - lastConsonantIndex - 1
    
    let closestVowelDistance = min(firstVowelDistance, lastVowelDistance)
    
    let closestVowel = vowels[closestVowelDistance]
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var closestVowel = ""
    var currentVowel = ""
    var isVowel = false
    var isConsonant = false
    var isFirstVowel = true
    var isFirstConsonant = true
    
    for letter in word {
        if consonants.contains(letter) {
            isConsonant = true
            isFirstConsonant = false
        } else if isConsonant {
            isVowel = true
            isFirstVowel = false
            let index = consonants.firstIndex(of: letter)
            if index!= nil {
                let vowel = consonants[index! - 1]
                let distance = abs(vowel.distance(to: letter))
                if closestVowel == "" || distance < closestVowel.distance(to: letter) {
                    closestVowel = vowel
                }
            }
        }
    }
    
    return closestVowel
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var closestVowel = ""
    var currentVowel = ""
    var isVowel = false
    var isConsonant = false
    var isFirstVowel = true
    var isFirstConsonant = true
    
    for letter in word {
        if consonants.contains(letter) {
            isConsonant = true
            isFirstConsonant = false
        } else if isConsonant {
            isVowel = true
            isFirstVowel = false
            let index = consonants.firstIndex(of: letter)
            if index!= nil {
                let vowel = consonants[index! - 1]
                let distance = abs(vowel.distance(to: letter))
                if closestVowel == "" || distance < closestVowel.distance(to: letter) {
                    closestVowel = vowel
                }
            }
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var closestVowel = ""
    var closestDistance = 100
    var currentDistance = 0
    var currentVowel = ""
    
    for i in 0..<word.count {
        let currentLetter = word[word.count - 1 - i]
        
        if consonants.contains(currentLetter) {
            currentDistance = 0
        } else {
            currentDistance += 1
        }
        
        if currentDistance < closestDistance {
            closestDistance = currentDistance
            closestVowel = currentLetter
        }
    }
    
    return closestVowel
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var closestVowel = ""
    var closestDistance = 100
    var currentDistance = 0
    var currentVowel = ""
    
    for i in 0..<word.count {
        let currentLetter = word[word.count - 1 - i]
        
        if consonants.contains(currentLetter) {
            currentDistance = 0
        } else {
            currentDistance += 1
        }
        
        if currentDistance < closestDistance {
            closestDistance = currentDistance
            closestVowel = currentLetter
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var result = ""
    var index = 0
    var isVowel = false
    while index < word.count {
        let currentChar = word[word.index(word.startIndex, offsetBy: index)]
        if consonants.contains(currentChar) {
            isVowel = false
        } else {
            isVowel = true
        }
        if isVowel {
            let previousChar = word[word.index(word.startIndex, offsetBy: index - 1)]
            let nextChar = word[word.index(word.startIndex, offsetBy: index + 1)]
            if consonants.contains(previousChar) && consonants.contains(nextChar) {
                result = currentChar
                break
            }
        }
        index += 1
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var result = ""
    var index = 0
    var isVowel = false
    while index < word.count {
        let currentChar = word[word.index(word.startIndex, offsetBy: index)]
        if consonants.contains(currentChar) {
            isVowel = false
        } else {
            isVowel = true
        }
        if isVowel {
            let previousChar = word[word.index(word.startIndex, offsetBy: index - 1)]
            let nextChar = word[word.index(word.startIndex, offsetBy: index + 1)]
            if consonants.contains(previousChar) && consonants.contains(nextChar) {
                result = currentChar
                break
            }
        }
        index += 1
    }
    return result
}
```

func getClosestVowel(word: String) -> String {
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var closestVowel = ""
    var closestDistance = 0
    
    for (index, character) in word.reversed().enumerated() {
        if consonants.contains(character.lowercased()) {
            let distance = index - closestDistance
            if distance > 0 {
                closestVowel = word[index]
                closestDistance = index
            }
        }
    }
    
    return closestVowel
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var closestVowel = ""
    var closestDistance = 0
    
    for (index, character) in word.reversed().enumerated() {
        if consonants.contains(character.lowercased()) {
            let distance = index - closestDistance
            if distance > 0 {
                closestVowel = word[index]
                closestDistance = index
            }
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var result = ""
    var isVowel = false
    var isConsonant = false
    var isFirstVowel = true
    var isLastVowel = false
    var lastVowel = ""
    
    for char in word {
        if consonants.contains(String(char)) {
            isConsonant = true
        } else {
            isConsonant = false
        }
        
        if isConsonant &&!isVowel {
            isVowel = true
            isFirstVowel = false
        } else if isVowel &&!isConsonant {
            isVowel = false
            isLastVowel = true
        }
        
        if isVowel &&!isFirstVowel {
            result = String(char)
            break
        }
    }
    
    if isLastVowel {
        return result
    } else {
        return ""
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var result = ""
    var isVowel = false
    var isConsonant = false
    var isFirstVowel = true
    var isLastVowel = false
    var lastVowel = ""
    
    for char in word {
        if consonants.contains(String(char)) {
            isConsonant = true
        } else {
            isConsonant = false
        }
        
        if isConsonant &&!isVowel {
            isVowel = true
            isFirstVowel = false
        } else if isVowel &&!isConsonant {
            isVowel = false
            isLastVowel = true
        }
        
        if isVowel &&!isFirstVowel {
            result = String(char)
            break
        }
    }
    
    if isLastVowel {
        return result
    } else {
        return ""
    }
}
```

func getClosestVowel(word: String) -> String {
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var result = ""
    var index = 0
    while index < word.count {
        if consonants.contains(word[index]) {
            index += 1
            continue
        }
        if let vowel = vowels.first(where: { $0 == word[index] }) {
            result = vowel
            break
        }
        index += 1
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var result = ""
    var index = 0
    while index < word.count {
        if consonants.contains(word[index]) {
            index += 1
            continue
        }
        if let vowel = vowels.first(where: { $0 == word[index] }) {
            result = vowel
            break
        }
        index += 1
    }
    return result
}
```

func getClosestVowel(word: String) -> String {
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var closestVowel = ""
    var closestDistance = 0
    
    for i in 0..<word.count {
        let currentChar = word[word.count - 1 - i]
        if consonants.contains(currentChar.lowercased()) {
            let currentDistance = i
            if currentDistance > closestDistance {
                closestVowel = ""
                closestDistance = currentDistance
            }
        } else if currentChar.lowercased() == "a" || currentChar.lowercased() == "e" || currentChar.lowercased() == "i" || currentChar.lowercased() == "o" || currentChar.lowercased() == "u" {
            let currentDistance = i
            if currentDistance > closestDistance {
                closestVowel = String(currentChar)
                closestDistance = currentDistance
            }
        }
    }
    
    return closestVowel
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var closestVowel = ""
    var closestDistance = 0
    
    for i in 0..<word.count {
        let currentChar = word[word.count - 1 - i]
        if consonants.contains(currentChar.lowercased()) {
            let currentDistance = i
            if currentDistance > closestDistance {
                closestVowel = ""
                closestDistance = currentDistance
            }
        } else if currentChar.lowercased() == "a" || currentChar.lowercased() == "e" || currentChar.lowercased() == "i" || currentChar.lowercased() == "o" || currentChar.lowercased() == "u" {
            let currentDistance = i
            if currentDistance > closestDistance {
                closestVowel = String(currentChar)
                closestDistance = currentDistance
            }
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    guard let first = word.first, let last = word.last else {
        return ""
    }
    
    let consonants = word.filter {!$0.isVowel }
    let consonantsCount = consonants.count
    
    guard consonantsCount > 1 else {
        return ""
    }
    
    let lastConsonantIndex = consonants.firstIndex(of: last)!
    let firstConsonantIndex = consonants.firstIndex(of: first)!
    
    let firstConsonantDistance = lastConsonantIndex - firstConsonantIndex
    let lastConsonantDistance = word.count - firstConsonantIndex - 1
    
    let firstConsonantVowelIndex = consonants.firstIndex(of: word[firstConsonantIndex])
    let lastConsonantVowelIndex = consonants.firstIndex(of: word[lastConsonantIndex])
    
    let firstConsonantVowel = firstConsonantVowelIndex.flatMap { consonants[$0] }
    let lastConsonantVowel = lastConsonantVowelIndex.flatMap { consonants[$0] }
    
    let firstConsonantVowelDistance = firstConsonantVowelIndex.flatMap { abs($0 - firstConsonantIndex) }
    let lastConsonantVowelDistance = lastConsonantVowelIndex.flatMap { abs($0 - lastConsonantIndex) }
    
    let closestVowel = firstConsonantVowel?? lastConsonantVowel
    
    guard let closestVowelDistance = closestVowel.flatMap { abs($0 - firstConsonantIndex) } else {
        return ""
    }
    
    return closestVowelDistance < firstConsonantDistance? firstConsonantVowel : lastConsonantVowel
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    guard let first = word.first, let last = word.last else {
        return ""
    }
    
    let consonants = word.filter {!$0.isVowel }
    let consonantsCount = consonants.count
    
    guard consonantsCount > 1 else {
        return ""
    }
    
    let lastConsonantIndex = consonants.firstIndex(of: last)!
    let firstConsonantIndex = consonants.firstIndex(of: first)!
    
    let firstConsonantDistance = lastConsonantIndex - firstConsonantIndex
    let lastConsonantDistance = word.count - firstConsonantIndex - 1
    
    let firstConsonantVowelIndex = consonants.firstIndex(of: word[firstConsonantIndex])
    let lastConsonantVowelIndex = consonants.firstIndex(of: word[lastConsonantIndex])
    
    let firstConsonantVowel = firstConsonantVowelIndex.flatMap { consonants[$0] }
    let lastConsonantVowel = lastConsonantVowelIndex.flatMap { consonants[$0] }
    
    let firstConsonantVowelDistance = firstConsonantVowelIndex.flatMap { abs($0 - firstConsonantIndex) }
    let lastConsonantVowelDistance = lastConsonantVowelIndex.flatMap { abs($0 - lastConsonantIndex) }
    
    let closestVowel = firstConsonantVowel?? lastConsonantVowel
    
    guard let closestVowelDistance = closestVowel.flatMap { abs($0 - firstConsonantIndex) } else {
        return ""
    }
    
    return closestVowelDistance < firstConsonantDistance? firstConsonantVowel : lastConsonantVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            foundVowel = true
            if lastConsonantIndex!= -1 {
                closestVowel = String(word[index])
                break
            }
        } else if!foundVowel {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            foundVowel = true
            if lastConsonantIndex!= -1 {
                closestVowel = String(word[index])
                break
            }
        } else if!foundVowel {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            foundVowel = true
            if lastConsonantIndex!= -1 {
                closestVowel = String(word[index])
                break
            }
        } else if!foundVowel {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            foundVowel = true
            if lastConsonantIndex!= -1 {
                closestVowel = String(word[index])
                break
            }
        } else if!foundVowel {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var foundVowel = false
    
    for char in word.reversed() {
        if vowels.contains(char.description.lowercased()) {
            closestVowel = String(char)
            foundVowel = true
            break
        }
    }
    
    return foundVowel? closestVowel : ""
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var foundVowel = false
    
    for char in word.reversed() {
        if vowels.contains(char.description.lowercased()) {
            closestVowel = String(char)
            foundVowel = true
            break
        }
    }
    
    return foundVowel? closestVowel : ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    
    for (index, character) in word.enumerated().reversed() {
        if vowels.contains(character) {
            foundVowel = true
            if index > 0 &&!vowels.contains(word[word.index(word.startIndex, offsetBy: index - 1)]) {
                closestVowel = String(character)
                break
            }
        }
    }
    
    return closestVowel
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    
    for (index, character) in word.enumerated().reversed() {
        if vowels.contains(character) {
            foundVowel = true
            if index > 0 &&!vowels.contains(word[word.index(word.startIndex, offsetBy: index - 1)]) {
                closestVowel = String(character)
                break
            }
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var foundVowel = false
    
    for (index, character) in word.enumerated().reversed() {
        if vowels.contains(character.lowercased()) {
            foundVowel = true
            if index > 0 && word[word.index(word.startIndex, offsetBy: index - 1)]!= " " {
                closestVowel = character
                break
            }
        }
    }
    
    return closestVowel.uppercased()
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var foundVowel = false
    
    for (index, character) in word.enumerated().reversed() {
        if vowels.contains(character.lowercased()) {
            foundVowel = true
            if index > 0 && word[word.index(word.startIndex, offsetBy: index - 1)]!= " " {
                closestVowel = character
                break
            }
        }
    }
    
    return closestVowel.uppercased()
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            foundVowel = true
            if lastConsonantIndex!= -1 {
                closestVowel = String(word[index])
                break
            }
        } else if!foundVowel {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            foundVowel = true
            if lastConsonantIndex!= -1 {
                closestVowel = String(word[index])
                break
            }
        } else if!foundVowel {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            foundVowel = true
            if lastConsonantIndex!= -1 {
                closestVowel = String(word[index])
                break
            }
        } else if!foundVowel {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            foundVowel = true
            if lastConsonantIndex!= -1 {
                closestVowel = String(word[index])
                break
            }
        } else if!foundVowel {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    var consonantCount = 0
    
    for char in word.reversed() {
        if vowels.contains(char) {
            foundVowel = true
            closestVowel = String(char)
            break
        } else if!foundVowel {
            consonantCount += 1
        }
    }
    
    if consonantCount == word.count - 1 {
        return ""
    } else {
        return closestVowel
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    var consonantCount = 0
    
    for char in word.reversed() {
        if vowels.contains(char) {
            foundVowel = true
            closestVowel = String(char)
            break
        } else if!foundVowel {
            consonantCount += 1
        }
    }
    
    if consonantCount == word.count - 1 {
        return ""
    } else {
        return closestVowel
    }
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    
    for (index, character) in word.enumerated().reversed() {
        if vowels.contains(character) {
            foundVowel = true
            if index > 0 &&!vowels.contains(word[word.index(word.startIndex, offsetBy: index - 1)]) {
                closestVowel = String(character)
                break
            }
        }
    }
    
    return closestVowel
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    
    for (index, character) in word.enumerated().reversed() {
        if vowels.contains(character) {
            foundVowel = true
            if index > 0 &&!vowels.contains(word[word.index(word.startIndex, offsetBy: index - 1)]) {
                closestVowel = String(character)
                break
            }
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    var consonantCount = 0
    
    for char in word.reversed() {
        if vowels.contains(char) {
            foundVowel = true
            closestVowel = String(char)
            break
        } else {
            consonantCount += 1
        }
    }
    
    if foundVowel && consonantCount > 1 {
        return closestVowel
    } else {
        return ""
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    var consonantCount = 0
    
    for char in word.reversed() {
        if vowels.contains(char) {
            foundVowel = true
            closestVowel = String(char)
            break
        } else {
            consonantCount += 1
        }
    }
    
    if foundVowel && consonantCount > 1 {
        return closestVowel
    } else {
        return ""
    }
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let characters = Array(word.lowercased())
    
    for i in stride(from: characters.count - 1, to: 1, by: -1) {
        if vowels.contains(characters[i]) {
            for j in stride(from: i - 1, to: 0, by: -1) {
                if characters[j]!= "a" && characters[j]!= "e" && characters[j]!= "i" && characters[j]!= "o" && characters[j]!= "u" {
                    return characters[i]
                }
            }
        }
    }
    
    return ""
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let characters = Array(word.lowercased())
    
    for i in stride(from: characters.count - 1, to: 1, by: -1) {
        if vowels.contains(characters[i]) {
            for j in stride(from: i - 1, to: 0, by: -1) {
                if characters[j]!= "a" && characters[j]!= "e" && characters[j]!= "i" && characters[j]!= "o" && characters[j]!= "u" {
                    return characters[i]
                }
            }
        }
    }
    
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let characters = Array(word.lowercased())
    
    for i in stride(from: characters.count - 1, to: 0, by: -1) {
        if vowels.contains(characters[i]) {
            for j in stride(from: i - 1, to: 0, by: -1) {
                if characters[j]!= "a" && characters[j]!= "e" && characters[j]!= "i" && characters[j]!= "o" && characters[j]!= "u" {
                    return characters[i]
                }
            }
        }
    }
    
    return ""
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let characters = Array(word.lowercased())
    
    for i in stride(from: characters.count - 1, to: 0, by: -1) {
        if vowels.contains(characters[i]) {
            for j in stride(from: i - 1, to: 0, by: -1) {
                if characters[j]!= "a" && characters[j]!= "e" && characters[j]!= "i" && characters[j]!= "o" && characters[j]!= "u" {
                    return characters[i]
                }
            }
        }
    }
    
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let characters = Array(word.lowercased())
    
    var lastVowelIndex = characters.count - 1
    while lastVowelIndex >= 0 {
        if vowels.contains(characters[lastVowelIndex]) {
            break
        }
        lastVowelIndex -= 1
    }
    
    if lastVowelIndex <= 0 {
        return ""
    }
    
    var closestVowelIndex = lastVowelIndex - 1
    while closestVowelIndex >= 0 {
        if vowels.contains(characters[closestVowelIndex]) {
            break
        }
        closestVowelIndex -= 1
    }
    
    return characters[closestVowelIndex].uppercased()
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let characters = Array(word.lowercased())
    
    var lastVowelIndex = characters.count - 1
    while lastVowelIndex >= 0 {
        if vowels.contains(characters[lastVowelIndex]) {
            break
        }
        lastVowelIndex -= 1
    }
    
    if lastVowelIndex <= 0 {
        return ""
    }
    
    var closestVowelIndex = lastVowelIndex - 1
    while closestVowelIndex >= 0 {
        if vowels.contains(characters[closestVowelIndex]) {
            break
        }
        closestVowelIndex -= 1
    }
    
    return characters[closestVowelIndex].uppercased()
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let characters = Array(word.lowercased())
    
    var lastVowelIndex = characters.count
    var lastVowel: Character?
    
    for (index, character) in characters.enumerated() {
        if vowels.contains(character) {
            lastVowelIndex = index
            lastVowel = character
        }
    }
    
    if lastVowelIndex == characters.count {
        return ""
    }
    
    for (index, character) in characters.enumerated(from: lastVowelIndex + 1) {
        if character.isLetter &&!vowels.contains(character) {
            return String(lastVowel!)
        }
    }
    
    return ""
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let characters = Array(word.lowercased())
    
    var lastVowelIndex = characters.count
    var lastVowel: Character?
    
    for (index, character) in characters.enumerated() {
        if vowels.contains(character) {
            lastVowelIndex = index
            lastVowel = character
        }
    }
    
    if lastVowelIndex == characters.count {
        return ""
    }
    
    for (index, character) in characters.enumerated(from: lastVowelIndex + 1) {
        if character.isLetter &&!vowels.contains(character) {
            return String(lastVowel!)
        }
    }
    
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let characters = Array(word.lowercased())
    
    var lastVowelIndex = characters.count - 1
    while lastVowelIndex >= 0 {
        if vowels.contains(characters[lastVowelIndex]) {
            break
        }
        lastVowelIndex -= 1
    }
    
    if lastVowelIndex < 1 {
        return ""
    }
    
    var closestVowelIndex = lastVowelIndex - 1
    while closestVowelIndex >= 0 {
        if vowels.contains(characters[closestVowelIndex]) {
            break
        }
        closestVowelIndex -= 1
    }
    
    return characters[closestVowelIndex]
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let characters = Array(word.lowercased())
    
    var lastVowelIndex = characters.count - 1
    while lastVowelIndex >= 0 {
        if vowels.contains(characters[lastVowelIndex]) {
            break
        }
        lastVowelIndex -= 1
    }
    
    if lastVowelIndex < 1 {
        return ""
    }
    
    var closestVowelIndex = lastVowelIndex - 1
    while closestVowelIndex >= 0 {
        if vowels.contains(characters[closestVowelIndex]) {
            break
        }
        closestVowelIndex -= 1
    }
    
    return characters[closestVowelIndex]
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let characters = Array(word.lowercased())
    
    var lastVowelIndex = characters.count - 1
    while lastVowelIndex >= 0 {
        if vowels.contains(characters[lastVowelIndex]) {
            break
        }
        lastVowelIndex -= 1
    }
    
    if lastVowelIndex <= 0 {
        return ""
    }
    
    var closestVowelIndex = lastVowelIndex - 1
    while closestVowelIndex >= 0 {
        if vowels.contains(characters[closestVowelIndex]) {
            break
        }
        closestVowelIndex -= 1
    }
    
    if closestVowelIndex < 0 {
        return ""
    }
    
    return characters[closestVowelIndex]
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let characters = Array(word.lowercased())
    
    var lastVowelIndex = characters.count - 1
    while lastVowelIndex >= 0 {
        if vowels.contains(characters[lastVowelIndex]) {
            break
        }
        lastVowelIndex -= 1
    }
    
    if lastVowelIndex <= 0 {
        return ""
    }
    
    var closestVowelIndex = lastVowelIndex - 1
    while closestVowelIndex >= 0 {
        if vowels.contains(characters[closestVowelIndex]) {
            break
        }
        closestVowelIndex -= 1
    }
    
    if closestVowelIndex < 0 {
        return ""
    }
    
    return characters[closestVowelIndex]
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let characters = Array(word.lowercased())
    
    for i in stride(from: characters.count - 1, to: 0, by: -1) {
        if vowels.contains(characters[i]) {
            for j in stride(from: i - 1, to: 0, by: -1) {
                if characters[j]!= "a" && characters[j]!= "e" && characters[j]!= "i" && characters[j]!= "o" && characters[j]!= "u" {
                    return characters[i]
                }
            }
        }
    }
    
    return ""
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let characters = Array(word.lowercased())
    
    for i in stride(from: characters.count - 1, to: 0, by: -1) {
        if vowels.contains(characters[i]) {
            for j in stride(from: i - 1, to: 0, by: -1) {
                if characters[j]!= "a" && characters[j]!= "e" && characters[j]!= "i" && characters[j]!= "o" && characters[j]!= "u" {
                    return characters[i]
                }
            }
        }
    }
    
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let characters = Array(word.lowercased())
    
    var lastVowelIndex = characters.count - 1
    while lastVowelIndex >= 0 {
        if vowels.contains(characters[lastVowelIndex]) {
            break
        }
        lastVowelIndex -= 1
    }
    
    if lastVowelIndex < 1 {
        return ""
    }
    
    var closestVowelIndex = lastVowelIndex - 1
    while closestVowelIndex >= 0 {
        if vowels.contains(characters[closestVowelIndex]) {
            break
        }
        closestVowelIndex -= 1
    }
    
    if closestVowelIndex < 0 {
        return ""
    }
    
    return characters[closestVowelIndex]
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let characters = Array(word.lowercased())
    
    var lastVowelIndex = characters.count - 1
    while lastVowelIndex >= 0 {
        if vowels.contains(characters[lastVowelIndex]) {
            break
        }
        lastVowelIndex -= 1
    }
    
    if lastVowelIndex < 1 {
        return ""
    }
    
    var closestVowelIndex = lastVowelIndex - 1
    while closestVowelIndex >= 0 {
        if vowels.contains(characters[closestVowelIndex]) {
            break
        }
        closestVowelIndex -= 1
    }
    
    if closestVowelIndex < 0 {
        return ""
    }
    
    return characters[closestVowelIndex]
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let characters = Array(word.lowercased())
    
    var lastVowelIndex = characters.count - 1
    while lastVowelIndex >= 0 {
        if vowels.contains(characters[lastVowelIndex]) {
            break
        }
        lastVowelIndex -= 1
    }
    
    if lastVowelIndex < 1 {
        return ""
    }
    
    var closestVowelIndex = lastVowelIndex - 1
    while closestVowelIndex >= 0 {
        if vowels.contains(characters[closestVowelIndex]) {
            break
        }
        closestVowelIndex -= 1
    }
    
    return characters[closestVowelIndex]
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let characters = Array(word.lowercased())
    
    var lastVowelIndex = characters.count - 1
    while lastVowelIndex >= 0 {
        if vowels.contains(characters[lastVowelIndex]) {
            break
        }
        lastVowelIndex -= 1
    }
    
    if lastVowelIndex < 1 {
        return ""
    }
    
    var closestVowelIndex = lastVowelIndex - 1
    while closestVowelIndex >= 0 {
        if vowels.contains(characters[closestVowelIndex]) {
            break
        }
        closestVowelIndex -= 1
    }
    
    return characters[closestVowelIndex]
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let characters = Array(word.lowercased())
    
    var lastVowelIndex = characters.count - 1
    while lastVowelIndex >= 0 {
        if vowels.contains(characters[lastVowelIndex]) {
            break
        }
        lastVowelIndex -= 1
    }
    
    if lastVowelIndex == 0 {
        return ""
    }
    
    var closestVowelIndex = lastVowelIndex - 1
    while closestVowelIndex >= 0 {
        if vowels.contains(characters[closestVowelIndex]) {
            break
        }
        closestVowelIndex -= 1
    }
    
    return characters[closestVowelIndex]
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let characters = Array(word.lowercased())
    
    var lastVowelIndex = characters.count - 1
    while lastVowelIndex >= 0 {
        if vowels.contains(characters[lastVowelIndex]) {
            break
        }
        lastVowelIndex -= 1
    }
    
    if lastVowelIndex == 0 {
        return ""
    }
    
    var closestVowelIndex = lastVowelIndex - 1
    while closestVowelIndex >= 0 {
        if vowels.contains(characters[closestVowelIndex]) {
            break
        }
        closestVowelIndex -= 1
    }
    
    return characters[closestVowelIndex]
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            if lastConsonantIndex!= -1 {
                let distance = word.count - index
                let closestDistance = word.count - lastConsonantIndex
                if distance < closestDistance {
                    closestVowel = String(character)
                }
            }
        } else if character.isLetter {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            if lastConsonantIndex!= -1 {
                let distance = word.count - index
                let closestDistance = word.count - lastConsonantIndex
                if distance < closestDistance {
                    closestVowel = String(character)
                }
            }
        } else if character.isLetter {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            if lastConsonantIndex!= -1 {
                let distance = word.count - index
                if closestVowel.isEmpty || distance < word.count - closestVowel.firstIndex(of: character)! {
                    closestVowel = String(character)
                }
            }
        } else {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            if lastConsonantIndex!= -1 {
                let distance = word.count - index
                if closestVowel.isEmpty || distance < word.count - closestVowel.firstIndex(of: character)! {
                    closestVowel = String(character)
                }
            }
        } else {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            if lastConsonantIndex!= -1 {
                let distance = word.count - index
                if closestVowel.isEmpty || distance < word.count - closestVowel.count {
                    closestVowel = String(character)
                }
            }
        } else if!vowels.contains(character) {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            if lastConsonantIndex!= -1 {
                let distance = word.count - index
                if closestVowel.isEmpty || distance < word.count - closestVowel.count {
                    closestVowel = String(character)
                }
            }
        } else if!vowels.contains(character) {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            if lastConsonantIndex!= -1 {
                let distance = word.count - index
                if distance < word.count - lastConsonantIndex {
                    closestVowel = String(character)
                }
            }
            lastConsonantIndex = -1
        } else if!vowels.contains(character) {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            if lastConsonantIndex!= -1 {
                let distance = word.count - index
                if distance < word.count - lastConsonantIndex {
                    closestVowel = String(character)
                }
            }
            lastConsonantIndex = -1
        } else if!vowels.contains(character) {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false
    
    for character in word.reversed() {
        if vowels.contains(character) && foundConsonant {
            closestVowel = String(character)
            break
        } else if!vowels.contains(character) {
            foundConsonant = true
        }
    }
    
    return closestVowel
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false
    
    for character in word.reversed() {
        if vowels.contains(character) && foundConsonant {
            closestVowel = String(character)
            break
        } else if!vowels.contains(character) {
            foundConsonant = true
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            if lastConsonantIndex!= -1 {
                let distance = word.count - index
                let closestDistance = word.count - lastConsonantIndex
                if closestDistance > distance {
                    closestVowel = String(character)
                }
                break
            }
        } else if!vowels.contains(character) {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            if lastConsonantIndex!= -1 {
                let distance = word.count - index
                let closestDistance = word.count - lastConsonantIndex
                if closestDistance > distance {
                    closestVowel = String(character)
                }
                break
            }
        } else if!vowels.contains(character) {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            if lastConsonantIndex!= -1 {
                let distance = word.count - index
                let closestDistance = word.count - lastConsonantIndex
                if closestDistance > distance {
                    closestVowel = String(character)
                }
            }
        } else if character.isLetter {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            if lastConsonantIndex!= -1 {
                let distance = word.count - index
                let closestDistance = word.count - lastConsonantIndex
                if closestDistance > distance {
                    closestVowel = String(character)
                }
            }
        } else if character.isLetter {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            if lastConsonantIndex!= -1 {
                let distance = word.count - index
                let closestDistance = word.count - lastConsonantIndex
                if closestDistance > distance {
                    closestVowel = String(character)
                }
            }
        } else if character.isLetter {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            if lastConsonantIndex!= -1 {
                let distance = word.count - index
                let closestDistance = word.count - lastConsonantIndex
                if closestDistance > distance {
                    closestVowel = String(character)
                }
            }
        } else if character.isLetter {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            if lastConsonantIndex!= -1 {
                let distance = word.count - index
                let closestDistance = word.count - lastConsonantIndex
                if distance < closestDistance {
                    closestVowel = String(character)
                }
            }
        } else if!vowels.contains(character) {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            if lastConsonantIndex!= -1 {
                let distance = word.count - index
                let closestDistance = word.count - lastConsonantIndex
                if distance < closestDistance {
                    closestVowel = String(character)
                }
            }
        } else if!vowels.contains(character) {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            if lastConsonantIndex!= -1 {
                let distance = word.count - index
                let closestDistance = word.count - lastConsonantIndex
                if closestDistance > distance {
                    closestVowel = String(character)
                }
            }
            lastConsonantIndex = -1
        } else if!vowels.contains(character) {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            if lastConsonantIndex!= -1 {
                let distance = word.count - index
                let closestDistance = word.count - lastConsonantIndex
                if closestDistance > distance {
                    closestVowel = String(character)
                }
            }
            lastConsonantIndex = -1
        } else if!vowels.contains(character) {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}
```

import Foundation

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

```swift
import Foundation

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

/*
 You are given a word. Your task is to find the closest vowel that stands between 
 two consonants from the right side of the word (case sensitive).
 Vowels in the beginning and ending doesn't count. Return empty string if you didn't
 find any vowel met the above condition. 
 You may assume that the given string contains English letter only.
 Example:
 getClosestVowel(word: "yogurt") == "u"
 getClosestVowel(word: "FULL") == "U"
 getClosestVowel(word: "quick") == ""
 getClosestVowel(word: "ab") == ""
 */
func getClosestVowel(word: String) -> String {
    
    
    
    var vow

import Foundation

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

```swift
import Foundation

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

/*
 You are given a word. Your task is to find the closest vowel that stands between 
 two consonants from the right side of the word (case sensitive).
 Vowels in the beginning and ending doesn't count. Return empty string if you didn't
 find any vowel met the above condition. 
 You may assume that the given string contains English letter only.
 Example:
 getClosestVowel(word: "yogurt") == "u"
 getClosestVowel(word: "FULL") == "U"
 getClosestVowel(word: "quick") == ""
 getClosestVowel(word: "ab") == ""
 */
func getClosestVowel(word: String) -> String {

import Foundation

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

```swift
import Foundation

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

/*
 You are given a word. Your task is to find the closest vowel that stands between 
 two consonants from the right side of the word (case sensitive).
 Vowels in the beginning and ending doesn't count. Return empty string if you didn't
 find any vowel met the above condition. 
 You may assume that the given string contains English letter only.
 Example:
 getClosestVowel(word: "yogurt") == "u"
 getClosestVowel(word: "FULL") == "U"
 getClosestVowel(word: "quick") == ""
 getClosestVowel(word: "ab") == ""
 */
func getClosestVowel(word: String) -> String {
    
    
    
    var

import Foundation

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

```swift
import Foundation

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

/*
 You are given a word. Your task is to find the closest vowel that stands between 
 two consonants from the right side of the word (case sensitive).
 Vowels in the beginning and ending doesn't count. Return empty string if you didn't
 find any vowel met the above condition. 
 You may assume that the given string contains English letter only.
 Example:
 getClosestVowel(word: "yogurt") == "u"
 getClosestVowel(word: "FULL") == "U"
 getClosestVowel(word: "quick") == ""
 getClosestVowel(word: "ab") == ""
 */
func getClosestVowel(word: String) -> String {

import Foundation

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

```swift
import Foundation

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

/*
 You are given a word. Your task is to find the closest vowel that stands between 
 two consonants from the right side of the word (case sensitive).
 Vowels in the beginning and ending doesn't count. Return empty string if you didn't
 find any vowel met the above condition. 
 You may assume that the given string contains English letter only.
 Example:
 getClosestVowel(word: "yogurt") == "u"
 getClosestVowel(word: "FULL") == "U"
 getClosestVowel(word: "quick") == ""
 getClosestVowel(word: "ab") == ""
 */
func getClosestVowel(word: String) -> String {
    
    
    var result =

import Foundation

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

```swift
import Foundation

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

/*
 You are given a word. Your task is to find the closest vowel that stands between 
 two consonants from the right side of the word (case sensitive).
 Vowels in the beginning and ending doesn't count. Return empty string if you didn't
 find any vowel met the above condition. 
 You may assume that the given string contains English letter only.
 Example:
 getClosestVowel(word: "yogurt") == "u"
 getClosestVowel(word: "FULL") == "U"
 getClosestVowel(word: "quick") == ""
 getClosestVowel(word: "ab") == ""
 */
func getClosestVowel(word: String) -> String {

import Foundation

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

```swift
import Foundation

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

/*
 You are given a word. Your task is to find the closest vowel that stands between 
 two consonants from the right side of the word (case sensitive).
 Vowels in the beginning and ending doesn't count. Return empty string if you didn't
 find any vowel met the above condition. 
 You may assume that the given string contains English letter only.
 Example:
 getClosestVowel(word: "yogurt") == "u"
 getClosestVowel(word: "FULL") == "U"
 getClosestVowel(word: "quick") == ""
 getClosestVowel(word: "ab") == ""
 */
func getClosestVowel(word: String) -> String {

import Foundation

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

```swift
import Foundation

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

/*
 You are given a word. Your task is to find the closest vowel that stands between 
 two consonants from the right side of the word (case sensitive).
 Vowels in the beginning and ending doesn't count. Return empty string if you didn't
 find any vowel met the above condition. 
 You may assume that the given string contains English letter only.
 Example:
 getClosestVowel(word: "yogurt") == "u"
 getClosestVowel(word: "FULL") == "U"
 getClosestVowel(word: "quick") == ""
 getClosestVowel(word: "ab") == ""
 */
func getClosestVowel(word: String) -> String {
    

import Foundation

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

```swift
import Foundation

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

/*
 You are given a word. Your task is to find the closest vowel that stands between 
 two consonants from the right side of the word (case sensitive).
 Vowels in the beginning and ending doesn't count. Return empty string if you didn't
 find any vowel met the above condition. 
 You may assume that the given string contains English letter only.
 Example:
 getClosestVowel(word: "yogurt") == "u"
 getClosestVowel(word: "FULL") == "U"
 getClosestVowel(word: "quick") == ""
 getClosestVowel(word: "ab") == ""
 */
func getClosestVowel(word: String) -> String {

import Foundation

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

```swift
import Foundation

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

/*
 You are given a word. Your task is to find the closest vowel that stands between 
 two consonants from the right side of the word (case sensitive).
 Vowels in the beginning and ending doesn't count. Return empty string if you didn't
 find any vowel met the above condition. 
 You may assume that the given string contains English letter only.
 Example:
 getClosestVowel(word: "yogurt") == "u"
 getClosestVowel(word: "FULL") == "U"
 getClosestVowel(word: "quick") == ""
 getClosestVowel(word: "ab") == ""
 */
func getClosestVowel(word: String) -> String {

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {








1. The given string contains only

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {
1. The input will only contains English alphabets, both uppercase and will be lowercase and English letters (a-English characters only.

    2.
    

    

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {





1. The input will always valid and will not start with alphabet is not contain any leading, including one or more than one and only contain English vowels, numbers and will not include English 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.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {



1. The given string contains only alphabets, lowercase sensitive
 2 or



2.
3.

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {



1. The input will only contains alphabets English al

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {

1. The input will only contains English alphabets [a- English alphabets, both lowercase English letters (a- English

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {


1. The input will only

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {


Here is a- only a, e, e, e, i, i, i, i, u, o, i, or i, or
 o, or
 i, u, o, e, or

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {








1. the input string contains only contains English alphabetic
 2- lowercase English letters (a- letters (a- case (

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var lastVowelIndex: Int?
    for i in word.reversed().enumerated() {
        if vowels.contains(i.element) {
            if let lastVowelIndex = lastVowelIndex, let nextVowelIndex = word.index(word.startIndex, offsetBy: i.offset), lastVowelIndex < nextVowelIndex && nextVowelIndex - lastVowelIndex > 2 {
                lastVowelIndex = i.offset
            }
        }
    }
    return lastVowelIndex != nil ? String(word[word.index(word.startIndex, offsetBy: lastVowelIndex!)]) : ""
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var lastVowelIndex: Int?
    for i in word.reversed().enumerated() {
        if vowels.contains(i.element) {
            if let lastVowelIndex = lastVowelIndex, let nextVowelIndex = word.index(word.startIndex, offsetBy: i.offset), lastVowelIndex < nextVowelIndex && nextVowelIndex - lastVowelIndex > 2 {
                lastVowelIndex = i.offset
            }
        }
    }
    return lastVowelIndex != nil ? String(word[word.index(word.startIndex, offsetBy: lastVowelIndex!)]) : ""
}

print(getClosestVowel(word: "yogurt")) // "u"
print(getClosestVowel(word: "FULL"))   // "U"
print(getClosestVowel(word: "quick"))  // ""
print(getClosestVowel(word: "ab"))     // ""
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var lastVowelIndex: Int?
    for index in word.index(word.startIndex, offsetBy: 1)..<word.endIndex {
        if vowels.contains(String(word[index])) {
            lastVowelIndex = index
        } else if let lastIndex = lastVowelIndex, word[lastIndex] != word[index] && vowels.contains(String(word[lastIndex])) {
            return String(word[lastIndex])
        }
    }
    return ""
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var lastVowelIndex: Int?
    for index in word.index(word.startIndex, offsetBy: 1)..<word.endIndex {
        if vowels.contains(String(word[index])) {
            lastVowelIndex = index
        } else if let lastIndex = lastVowelIndex, word[lastIndex] != word[index] && vowels.contains(String(word[lastIndex])) {
            return String(word[lastIndex])
        }
    }
    return ""
}

print(getClosestVowel(word: "yogurt")) // prints "u"
print(getClosestVowel(word: "FULL")) // prints "U"
print(getClosestVowel(word: "quick")) // prints ""
print(getClosestVowel(word: "ab")) // prints ""
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var lastVowelIndex: Int?
    for (index, char) in word.enumerated() {
        if vowels.contains(String(char)) {
            if let lastVowelIndex = lastVowelIndex, index - lastVowelIndex > 2 {
                return String(char)
            }
            lastVowelIndex = index
        }
    }
    return ""
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var lastVowelIndex: Int?
    for (index, char) in word.enumerated() {
        if vowels.contains(String(char)) {
            if let lastVowelIndex = lastVowelIndex, index - lastVowelIndex > 2 {
                return String(char)
            }
            lastVowelIndex = index
        }
    }
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var lastVowelIndex: Int? = nil
    for index in word.reversed().enumerated() {
        if vowels.contains(String(index.element)) {
            if lastVowelIndex != nil && index.offset - lastVowelIndex != nil && index.offset - lastVowelIndex! < 2 {
                return String(index.element)
            }
            lastVowelIndex = index.offset
        }
    }
    return ""
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var lastVowelIndex: Int? = nil
    for index in word.reversed().enumerated() {
        if vowels.contains(String(index.element)) {
            if lastVowelIndex != nil && index.offset - lastVowelIndex != nil && index.offset - lastVowelIndex! < 2 {
                return String(index.element)
            }
            lastVowelIndex = index.offset
        }
    }
    return ""
}
```

func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var wordArray = Array(word.reversed())
    var closestVowel = ""
    
    for i in 1..<wordArray.count - 1 {
        if vowels.contains(String(wordArray[i])) {
            if vowels.contains(String(wordArray[i-1])) && vowels.contains(String(wordArray[i+1])) {
                closestVowel = String(wordArray[i])
                break
            }
        }
    }
    
    return closestVowel
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var wordArray = Array(word.reversed())
    var closestVowel = ""
    
    for i in 1..<wordArray.count - 1 {
        if vowels.contains(String(wordArray[i])) {
            if vowels.contains(String(wordArray[i-1])) && vowels.contains(String(wordArray[i+1])) {
                closestVowel = String(wordArray[i])
                break
            }
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var wordArray = Array(word)
    var closestVowel = ""
    
    for i in wordArray.index(wordArray.count - 1, offsetBy: -1)..<wordArray.count {
        let currentChar = wordArray[i]
        if vowels.contains(currentChar) {
            if let previousChar = wordArray[i - 1], vowels.contains(previousChar) {
                if let nextChar = wordArray[i + 1], vowels.contains(nextChar) {
                    closestVowel = currentChar
                }
            }
        }
    }
    
    return closestVowel
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var wordArray = Array(word)
    var closestVowel = ""
    
    for i in wordArray.index(wordArray.count - 1, offsetBy: -1)..<wordArray.count {
        let currentChar = wordArray[i]
        if vowels.contains(currentChar) {
            if let previousChar = wordArray[i - 1], vowels.contains(previousChar) {
                if let nextChar = wordArray[i + 1], vowels.contains(nextChar) {
                    closestVowel = currentChar
                }
            }
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var lastVowelIndex: Int?
    for index in word.reversed().enumerated() {
        if vowels.contains(String(index.element)) && lastVowelIndex != nil {
            if index.offset - lastVowelIndex! <= 2 {
                return String(index.element)
            }
        }
        lastVowelIndex = index.offset
    }
    return ""
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var lastVowelIndex: Int?
    for index in word.reversed().enumerated() {
        if vowels.contains(String(index.element)) && lastVowelIndex != nil {
            if index.offset - lastVowelIndex! <= 2 {
                return String(index.element)
            }
        }
        lastVowelIndex = index.offset
    }
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var lastVowelIndex: Int? = nil
    for (index, char) in word.enumerated() {
        if vowels.contains(String(char)) {
            if let lastVowelIndex = lastVowelIndex {
                if abs(index - lastVowelIndex) <= 1 {
                    return String(char)
                }
            }
            lastVowelIndex = index
        }
    }
    return ""
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var lastVowelIndex: Int? = nil
    for (index, char) in word.enumerated() {
        if vowels.contains(String(char)) {
            if let lastVowelIndex = lastVowelIndex {
                if abs(index - lastVowelIndex) <= 1 {
                    return String(char)
                }
            }
            lastVowelIndex = index
        }
    }
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var lastVowelIndex: Int? = nil
    for (index, char) in word.enumerated() {
        if vowels.contains(String(char)) {
            if lastVowelIndex != nil && index - lastVowelIndex! <= 2 {
                return String(char)
            }
            lastVowelIndex = index
        }
    }
    return ""
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var lastVowelIndex: Int? = nil
    for (index, char) in word.enumerated() {
        if vowels.contains(String(char)) {
            if lastVowelIndex != nil && index - lastVowelIndex! <= 2 {
                return String(char)
            }
            lastVowelIndex = index
        }
    }
    return ""
}
```

func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var wordArray = Array(word)
    var closestVowel = ""
    
    for i in wordArray.index(wordArray.count - 1, offsetBy: -1)..<wordArray.count {
        if vowels.contains(String(wordArray[i])) {
            if let index = wordArray[i..<wordArray[i+1]].firstIndex(of: wordArray[i]) {
                if closestVowel.count == 0 || abs(wordArray.count - index - 1) < abs(wordArray.count - closestVowel.index) {
                    closestVowel = String(wordArray[i])
                }
            }
        }
    }
    return closestVowel
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var wordArray = Array(word)
    var closestVowel = ""
    
    for i in wordArray.index(wordArray.count - 1, offsetBy: -1)..<wordArray.count {
        if vowels.contains(String(wordArray[i])) {
            if let index = wordArray[i..<wordArray[i+1]].firstIndex(of: wordArray[i]) {
                if closestVowel.count == 0 || abs(wordArray.count - index - 1) < abs(wordArray.count - closestVowel.index) {
                    closestVowel = String(wordArray[i])
                }
            }
        }
    }
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "AEIOUaeiou"
    var vowel: Character = ""
    var distance = word.count
    
    for i in stride(from: word.count - 1, through: 1, by: -1) {
        let currentChar = word[word.index(word.startIndex, offsetBy: i)]
        let nextChar = word[word.index(word.startIndex, offsetBy: i + 1)]
        if vowels.contains(currentChar) && !vowels.contains(nextChar) {
            let newDistance = abs(i - (word.index(word.startIndex, offsetBy: i + 1)).offset)
            if newDistance < distance {
                distance = newDistance
                vowel = currentChar
            }
        }
    }
    
    return String(vowel)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "AEIOUaeiou"
    var vowel: Character = ""
    var distance = word.count
    
    for i in stride(from: word.count - 1, through: 1, by: -1) {
        let currentChar = word[word.index(word.startIndex, offsetBy: i)]
        let nextChar = word[word.index(word.startIndex, offsetBy: i + 1)]
        if vowels.contains(currentChar) && !vowels.contains(nextChar) {
            let newDistance = abs(i - (word.index(word.startIndex, offsetBy: i + 1)).offset)
            if newDistance < distance {
                distance = newDistance
                vowel = currentChar
            }
        }
    }
    
    return String(vowel)
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "AEIOUaeiou"
    let characters = Array(word)
    for i in stride(from: characters.count - 2, through: 1, by: -1) {
        if vowels.contains(characters[i]) && !vowels.contains(characters[i-1]) && !vowels.contains(characters[i+1]) {
            return String(characters[i])
        }
    }
    return ""
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "AEIOUaeiou"
    let characters = Array(word)
    for i in stride(from: characters.count - 2, through: 1, by: -1) {
        if vowels.contains(characters[i]) && !vowels.contains(characters[i-1]) && !vowels.contains(characters[i+1]) {
            return String(characters[i])
        }
    }
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    for i in stride(from: word.count - 1, through: 1, by: -1) {
        let currentChar = String(word[word.index(word.startIndex, offsetBy: i)])
        let nextChar = String(word[word.index(word.startIndex, offsetBy: i + 1)])
        if !vowels.contains(currentChar) && vowels.contains(nextChar) {
            for j in stride(from: i, through: 1, by: -1) {
                let candidate = String(word[word.index(word.startIndex, offsetBy: j)])
                if vowels.contains(candidate) {
                    return candidate
                }
            }
        }
    }
    return ""
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    for i in stride(from: word.count - 1, through: 1, by: -1) {
        let currentChar = String(word[word.index(word.startIndex, offsetBy: i)])
        let nextChar = String(word[word.index(word.startIndex, offsetBy: i + 1)])
        if !vowels.contains(currentChar) && vowels.contains(nextChar) {
            for j in stride(from: i, through: 1, by: -1) {
                let candidate = String(word[word.index(word.startIndex, offsetBy: j)])
                if vowels.contains(candidate) {
                    return candidate
                }
            }
        }
    }
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    let characters = Array(word)
    for i in stride(from: word.count - 1, through: 1, by: -1) {
        if vowels.contains(characters[i]) && !vowels.contains(characters[i-1]) && !vowels.contains(characters[i+1]) {
            return String(characters[i])
        }
    }
    return ""
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    let characters = Array(word)
    for i in stride(from: word.count - 1, through: 1, by: -1) {
        if vowels.contains(characters[i]) && !vowels.contains(characters[i-1]) && !vowels.contains(characters[i+1]) {
            return String(characters[i])
        }
    }
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "AEIOUaeiou"
    let characters = Array(word)
    for i in stride(from: characters.count - 2, through: 1, by: -1) {
        if vowels.contains(characters[i]) && !vowels.contains(characters[i-1]) && !vowels.contains(characters[i+1]) {
            return String(characters[i])
        }
    }
    return ""
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "AEIOUaeiou"
    let characters = Array(word)
    for i in stride(from: characters.count - 2, through: 1, by: -1) {
        if vowels.contains(characters[i]) && !vowels.contains(characters[i-1]) && !vowels.contains(characters[i+1]) {
            return String(characters[i])
        }
    }
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var vowel: Character = ""
    var distance = word.count
    
    for i in stride(from: word.count - 1, through: 1, by: -1) {
        let currentChar = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(currentChar) {
            let currentDistance = abs(i)
            if currentDistance < distance && word[word.index(word.startIndex, offsetBy: i - 1)] in vowels == false && word[word.index(word.startIndex, offsetBy: i + 1)] in vowels == false {
                distance = currentDistance
                vowel = currentChar
            }
        }
    }
    
    return String(vowel)
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var vowel: Character = ""
    var distance = word.count
    
    for i in stride(from: word.count - 1, through: 1, by: -1) {
        let currentChar = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(currentChar) {
            let currentDistance = abs(i)
            if currentDistance < distance && word[word.index(word.startIndex, offsetBy: i - 1)] in vowels == false && word[word.index(word.startIndex, offsetBy: i + 1)] in vowels == false {
                distance = currentDistance
                vowel = currentChar
            }
        }
    }
    
    return String(vowel)
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "AEIOUaeiou"
    let characters = Array(word)
    for i in stride(from: characters.count - 2, through: 1, by: -1) {
        if vowels.contains(characters[i]) && !vowels.contains(characters[i-1]) && !vowels.contains(characters[i+1]) {
            return String(characters[i])
        }
    }
    return ""
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "AEIOUaeiou"
    let characters = Array(word)
    for i in stride(from: characters.count - 2, through: 1, by: -1) {
        if vowels.contains(characters[i]) && !vowels.contains(characters[i-1]) && !vowels.contains(characters[i+1]) {
            return String(characters[i])
        }
    }
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    for i in stride(from: word.count - 1, through: 1, by: -1) {
        let currentChar = String(word[word.index(word.startIndex, offsetBy: i)])
        let nextChar = String(word[word.index(word.startIndex, offsetBy: i + 1)])
        if !vowels.contains(currentChar) && vowels.contains(nextChar) {
            for j in stride(from: i, through: 1, by: -1) {
                let potentialVowel = String(word[word.index(word.startIndex, offsetBy: j)])
                if vowels.contains(potentialVowel) {
                    return potentialVowel
                }
            }
        }
    }
    return ""
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    for i in stride(from: word.count - 1, through: 1, by: -1) {
        let currentChar = String(word[word.index(word.startIndex, offsetBy: i)])
        let nextChar = String(word[word.index(word.startIndex, offsetBy: i + 1)])
        if !vowels.contains(currentChar) && vowels.contains(nextChar) {
            for j in stride(from: i, through: 1, by: -1) {
                let potentialVowel = String(word[word.index(word.startIndex, offsetBy: j)])
                if vowels.contains(potentialVowel) {
                    return potentialVowel
                }
            }
        }
    }
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    for i in stride(from: word.count - 1, through: 1, by: -1) {
        let currentChar = String(word[word.index(word.startIndex, offsetBy: i)])
        let nextChar = String(word[word.index(word.startIndex, offsetBy: i + 1)])
        if !vowels.contains(currentChar) && vowels.contains(nextChar) {
            for j in stride(from: i, through: 1, by: -1) {
                let potentialVowel = String(word[word.index(word.startIndex, offsetBy: j)])
                if vowels.contains(potentialVowel) {
                    return potentialVowel
                }
            }
        }
    }
    return ""
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    for i in stride(from: word.count - 1, through: 1, by: -1) {
        let currentChar = String(word[word.index(word.startIndex, offsetBy: i)])
        let nextChar = String(word[word.index(word.startIndex, offsetBy: i + 1)])
        if !vowels.contains(currentChar) && vowels.contains(nextChar) {
            for j in stride(from: i, through: 1, by: -1) {
                let potentialVowel = String(word[word.index(word.startIndex, offsetBy: j)])
                if vowels.contains(potentialVowel) {
                    return potentialVowel
                }
            }
        }
    }
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    for i in stride(from: word.count - 1, through: 1, by: -1) {
        let currentChar = String(word[word.index(word.startIndex, offsetBy: i)])
        let nextChar = String(word[word.index(word.startIndex, offsetBy: i + 1)])
        if !vowels.contains(currentChar) && vowels.contains(nextChar) {
            for j in stride(from: i, through: 1, by: -1) {
                let potentialVowel = String(word[word.index(word.startIndex, offsetBy: j)])
                if vowels.contains(potentialVowel) {
                    return potentialVowel
                }
            }
        }
    }
    return ""
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    for i in stride(from: word.count - 1, through: 1, by: -1) {
        let currentChar = String(word[word.index(word.startIndex, offsetBy: i)])
        let nextChar = String(word[word.index(word.startIndex, offsetBy: i + 1)])
        if !vowels.contains(currentChar) && vowels.contains(nextChar) {
            for j in stride(from: i, through: 1, by: -1) {
                let potentialVowel = String(word[word.index(word.startIndex, offsetBy: j)])
                if vowels.contains(potentialVowel) {
                    return potentialVowel
                }
            }
        }
    }
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z", "B", "C", "D", "F", "G", "H", "J", "K", "L", "M", "N", "P", "Q", "R", "S", "T", "V", "W", "X", "Y", "Z"]
    let wordArray = Array(word)
    for i in stride(from: wordArray.count - 1, through: 1, by: -1) {
        if vowels.contains(wordArray[i]) && consonants.contains(wordArray[i - 1]) && consonants.contains(wordArray[i + 1]) {
            return String(wordArray[i])
        }
    }
    return ""
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z", "B", "C", "D", "F", "G", "H", "J", "K", "L", "M", "N", "P", "Q", "R", "S", "T", "V", "W", "X", "Y", "Z"]
    let wordArray = Array(word)
    for i in stride(from: wordArray.count - 1, through: 1, by: -1) {
        if vowels.contains(wordArray[i]) && consonants.contains(wordArray[i - 1]) && consonants.contains(wordArray[i + 1]) {
            return String(wordArray[i])
        }
    }
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z", "B", "C", "D", "F", "G", "H", "J", "K", "L", "M", "N", "P", "Q", "R", "S", "T", "V", "W", "X", "Y", "Z"]
    
    let wordArray = Array(word)
    
    for i in stride(from: wordArray.count - 1, through: 1, by: -1) {
        let index = i - 1
        if index >= 0, let currentChar = wordArray[i], let prevChar = wordArray[index] {
            if vowels.contains(currentChar) && consonants.contains(prevChar) {
                return String(currentChar)
            }
        }
    }
    
    return ""
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z", "B", "C", "D", "F", "G", "H", "J", "K", "L", "M", "N", "P", "Q", "R", "S", "T", "V", "W", "X", "Y", "Z"]
    
    let wordArray = Array(word)
    
    for i in stride(from: wordArray.count - 1, through: 1, by: -1) {
        let index = i - 1
        if index >= 0, let currentChar = wordArray[i], let prevChar = wordArray[index] {
            if vowels.contains(currentChar) && consonants.contains(prevChar) {
                return String(currentChar)
            }
        }
    }
    
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z", "B", "C", "D", "F", "G", "H", "J", "K", "L", "M", "N", "P", "Q", "R", "S", "T", "V", "W", "X", "Y", "Z"]
    let wordArray = Array(word)
    for i in stride(from: wordArray.count - 2, through: 1, by: -1) {
        if vowels.contains(wordArray[i]) && consonants.contains(wordArray[i - 1]) && consonants.contains(wordArray[i + 1]) {
            return String(wordArray[i])
        }
    }
    return ""
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z", "B", "C", "D", "F", "G", "H", "J", "K", "L", "M", "N", "P", "Q", "R", "S", "T", "V", "W", "X", "Y", "Z"]
    let wordArray = Array(word)
    for i in stride(from: wordArray.count - 2, through: 1, by: -1) {
        if vowels.contains(wordArray[i]) && consonants.contains(wordArray[i - 1]) && consonants.contains(wordArray[i + 1]) {
            return String(wordArray[i])
        }
    }
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z", "B", "C", "D", "F", "G", "H", "J", "K", "L", "M", "N", "P", "Q", "R", "S", "T", "V", "W", "X", "Y", "Z"]
    let wordArray = Array(word)
    for i in stride(from: wordArray.count - 2, through: 1, by: -1) {
        if vowels.contains(wordArray[i]) && consonants.contains(wordArray[i - 1]) && consonants.contains(wordArray[i + 1]) {
            return String(wordArray[i])
        }
    }
    return ""
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z", "B", "C", "D", "F", "G", "H", "J", "K", "L", "M", "N", "P", "Q", "R", "S", "T", "V", "W", "X", "Y", "Z"]
    let wordArray = Array(word)
    for i in stride(from: wordArray.count - 2, through: 1, by: -1) {
        if vowels.contains(wordArray[i]) && consonants.contains(wordArray[i - 1]) && consonants.contains(wordArray[i + 1]) {
            return String(wordArray[i])
        }
    }
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    let consonants = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
    let wordArray = Array(word)
    for i in stride(from: wordArray.count - 2, through: 1, by: -1) {
        if vowels.contains(wordArray[i]) && consonants.contains(wordArray[i - 1]) && consonants.contains(wordArray[i + 1]) {
            return String(wordArray[i])
        }
    }
    return ""
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    let consonants = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
    let wordArray = Array(word)
    for i in stride(from: wordArray.count - 2, through: 1, by: -1) {
        if vowels.contains(wordArray[i]) && consonants.contains(wordArray[i - 1]) && consonants.contains(wordArray[i + 1]) {
            return String(wordArray[i])
        }
    }
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    let consonants = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
    
    let wordArray = Array(word)
    let wordLength = wordArray.count
    
    for i in stride(from: wordLength - 2, through: 1, by: -1) {
        let currentChar = wordArray[i]
        let nextChar = wordArray[i - 1]
        let previousChar = wordArray[i + 1]
        
        if vowels.contains(currentChar) && consonants.contains(nextChar) && consonants.contains(previousChar) {
            return String(currentChar)
        }
    }
    
    return ""
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    let consonants = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
    
    let wordArray = Array(word)
    let wordLength = wordArray.count
    
    for i in stride(from: wordLength - 2, through: 1, by: -1) {
        let currentChar = wordArray[i]
        let nextChar = wordArray[i - 1]
        let previousChar = wordArray[i + 1]
        
        if vowels.contains(currentChar) && consonants.contains(nextChar) && consonants.contains(previousChar) {
            return String(currentChar)
        }
    }
    
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    let consonants = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
    for i in stride(from: word.count - 1, through: 1, by: -1) {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(char) {
            let prevChar = word[word.index(word.startIndex, offsetBy: i - 1)]
            let nextChar = word[word.index(word.startIndex, offsetBy: i + 1)]
            if consonants.contains(prevChar) && consonants.contains(nextChar) {
                return String(char)
            }
        }
    }
    return ""
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    let consonants = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
    for i in stride(from: word.count - 1, through: 1, by: -1) {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(char) {
            let prevChar = word[word.index(word.startIndex, offsetBy: i - 1)]
            let nextChar = word[word.index(word.startIndex, offsetBy: i + 1)]
            if consonants.contains(prevChar) && consonants.contains(nextChar) {
                return String(char)
            }
        }
    }
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    let consonants = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
    let wordArray = Array(word)
    for i in stride(from: wordArray.count - 1, through: 1, by: -1) {
        if vowels.contains(wordArray[i]) && consonants.contains(wordArray[i - 1]) && consonants.contains(wordArray[i + 1]) {
            return String(wordArray[i])
        }
    }
    return ""
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    let consonants = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
    let wordArray = Array(word)
    for i in stride(from: wordArray.count - 1, through: 1, by: -1) {
        if vowels.contains(wordArray[i]) && consonants.contains(wordArray[i - 1]) && consonants.contains(wordArray[i + 1]) {
            return String(wordArray[i])
        }
    }
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    let consonants = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
    let wordArray = Array(word)
    let wordLength = wordArray.count
    
    for i in stride(from: wordLength - 2, through: 1, by: -1) {
        let currentChar = wordArray[i]
        let nextChar = wordArray[i - 1]
        let prevChar = wordArray[i + 1]
        
        if vowels.contains(currentChar) && consonants.contains(nextChar) && consonants.contains(prevChar) {
            return String(currentChar)
        }
    }
    
    return ""
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    let consonants = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
    let wordArray = Array(word)
    let wordLength = wordArray.count
    
    for i in stride(from: wordLength - 2, through: 1, by: -1) {
        let currentChar = wordArray[i]
        let nextChar = wordArray[i - 1]
        let prevChar = wordArray[i + 1]
        
        if vowels.contains(currentChar) && consonants.contains(nextChar) && consonants.contains(prevChar) {
            return String(currentChar)
        }
    }
    
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    let consonants = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
    let wordArray = Array(word)
    for i in stride(from: wordArray.count - 2, through: 1, by: -1) {
        if vowels.contains(wordArray[i]) && consonants.contains(wordArray[i - 1]) && consonants.contains(wordArray[i + 1]) {
            return String(wordArray[i])
        }
    }
    return ""
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    let consonants = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
    let wordArray = Array(word)
    for i in stride(from: wordArray.count - 2, through: 1, by: -1) {
        if vowels.contains(wordArray[i]) && consonants.contains(wordArray[i - 1]) && consonants.contains(wordArray[i + 1]) {
            return String(wordArray[i])
        }
    }
    return ""
}
```

import Foundation

func getClosestVowel(word: String) -> String {
    let vowels: Set<Character> = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var previousCharacter: Character?
    var closestVowel: Character?

    for character in word.reversed() {
        if let previous = previousCharacter {
            if vowels.contains(character) && !vowels.contains(previous) {
                closestVowel = character
                break
            }
        }
        previousCharacter = character
    }

    return String(closestVowel ?? "")
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
import Foundation

func getClosestVowel(word: String) -> String {
    let vowels: Set<Character> = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var previousCharacter: Character?
    var closestVowel: Character?

    for character in word.reversed() {
        if let previous = previousCharacter {
            if vowels.contains(character) && !vowels.contains(previous) {
                closestVowel = character
                break
            }
        }
        previousCharacter = character
    }

    return String(closestVowel ?? "")
}
```

import Foundation

func getClosestVowel(word: String) -> String {
    let vowels: Set<Character> = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var lastConsonant: Character?
    var closestVowel: Character?

    for char in word.reversed() {
        if vowels.contains(char) {
            if let last = lastConsonant {
                closestVowel = char
                break
            }
        } else {
            lastConsonant = char
        }
    }

    return String(closestVowel ?? "")
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
import Foundation

func getClosestVowel(word: String) -> String {
    let vowels: Set<Character> = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var lastConsonant: Character?
    var closestVowel: Character?

    for char in word.reversed() {
        if vowels.contains(char) {
            if let last = lastConsonant {
                closestVowel = char
                break
            }
        } else {
            lastConsonant = char
        }
    }

    return String(closestVowel ?? "")
}
```

import Foundation

func getClosestVowel(word: String) -> String {
    let vowels: Set<Character> = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var previousChar: Character?
    var closestVowel: Character?

    for char in word.reversed() {
        if let prev = previousChar, !vowels.contains(char), vowels.contains(prev) {
            closestVowel = prev
            break
        }
        previousChar = char
    }

    return String(closestVowel ?? "")
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
import Foundation

func getClosestVowel(word: String) -> String {
    let vowels: Set<Character> = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var previousChar: Character?
    var closestVowel: Character?

    for char in word.reversed() {
        if let prev = previousChar, !vowels.contains(char), vowels.contains(prev) {
            closestVowel = prev
            break
        }
        previousChar = char
    }

    return String(closestVowel ?? "")
}
```

import Foundation

func getClosestVowel(word: String) -> String {
    let vowels: Set<Character> = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var lastConsonant: Character?

    for char in word.reversed() {
        if !vowels.contains(char) {
            lastConsonant = char
        } else if lastConsonant != nil {
            return String(char)
        }
    }

    return ""
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
import Foundation

func getClosestVowel(word: String) -> String {
    let vowels: Set<Character> = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var lastConsonant: Character?

    for char in word.reversed() {
        if !vowels.contains(char) {
            lastConsonant = char
        } else if lastConsonant != nil {
            return String(char)
        }
    }

    return ""
}
```

import Foundation

func getClosestVowel(word: String) -> String {
    let vowels: Set<Character> = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var lastConsonant: Character?
    var closestVowel: Character?

    for char in word.reversed() {
        if !vowels.contains(char) {
            if lastConsonant != nil {
                closestVowel = char
                break
            }
            lastConsonant = char
        }
    }

    return closestVowel.map(String.init) ?? ""
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
import Foundation

func getClosestVowel(word: String) -> String {
    let vowels: Set<Character> = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var lastConsonant: Character?
    var closestVowel: Character?

    for char in word.reversed() {
        if !vowels.contains(char) {
            if lastConsonant != nil {
                closestVowel = char
                break
            }
            lastConsonant = char
        }
    }

    return closestVowel.map(String.init) ?? ""
}
```

import Foundation

func getClosestVowel(word: String) -> String {
    let vowels: Set<Character> = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var closestVowel: Character?

    for char in word.reversed() {
        if !vowels.contains(char) {
            if let vowel = closestVowel {
                return String(vowel)
            }
        } else {
            closestVowel = char
        }
    }

    return ""
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
import Foundation

func getClosestVowel(word: String) -> String {
    let vowels: Set<Character> = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var closestVowel: Character?

    for char in word.reversed() {
        if !vowels.contains(char) {
            if let vowel = closestVowel {
                return String(vowel)
            }
        } else {
            closestVowel = char
        }
    }

    return ""
}
```

import Foundation

func getClosestVowel(word: String) -> String {
    let vowels: Set<Character> = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var closestVowel = ""

    for i in stride(from: word.count - 2, through: 1, by: -1) {
        let currentChar = word[word.index(word.startIndex, offsetBy: i)]
        let prevChar = word[word.index(word.startIndex, offsetBy: i - 1)]
        let nextChar = word[word.index(word.startIndex, offsetBy: i + 1)]

        if vowels.contains(currentChar) && !vowels.contains(prevChar) && !vowels.contains(nextChar) {
            closestVowel = String(currentChar)
            break
        }
    }

    return closestVowel
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
import Foundation

func getClosestVowel(word: String) -> String {
    let vowels: Set<Character> = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var closestVowel = ""

    for i in stride(from: word.count - 2, through: 1, by: -1) {
        let currentChar = word[word.index(word.startIndex, offsetBy: i)]
        let prevChar = word[word.index(word.startIndex, offsetBy: i - 1)]
        let nextChar = word[word.index(word.startIndex, offsetBy: i + 1)]

        if vowels.contains(currentChar) && !vowels.contains(prevChar) && !vowels.contains(nextChar) {
            closestVowel = String(currentChar)
            break
        }
    }

    return closestVowel
}
```

import Foundation

func getClosestVowel(word: String) -> String {
    let vowels: Set<Character> = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var previousChar: Character?
    var closestVowel: Character?

    for char in word.reversed() {
        if let prev = previousChar, !vowels.contains(char), vowels.contains(prev) {
            closestVowel = prev
            break
        }
        previousChar = char
    }

    return String(closestVowel ?? "")
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
import Foundation

func getClosestVowel(word: String) -> String {
    let vowels: Set<Character> = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var previousChar: Character?
    var closestVowel: Character?

    for char in word.reversed() {
        if let prev = previousChar, !vowels.contains(char), vowels.contains(prev) {
            closestVowel = prev
            break
        }
        previousChar = char
    }

    return String(closestVowel ?? "")
}
```

import Foundation

func getClosestVowel(word: String) -> String {
    let vowels: Set<Character> = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var lastConsonant: Character?
    var closestVowel: Character?

    for char in word.reversed() {
        if !vowels.contains(char) {
            if let lastVowel = closestVowel {
                return String(lastVowel)
            }
            lastConsonant = char
        } else {
            if lastConsonant != nil {
                closestVowel = char
            }
        }
    }

    return ""
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
import Foundation

func getClosestVowel(word: String) -> String {
    let vowels: Set<Character> = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var lastConsonant: Character?
    var closestVowel: Character?

    for char in word.reversed() {
        if !vowels.contains(char) {
            if let lastVowel = closestVowel {
                return String(lastVowel)
            }
            lastConsonant = char
        } else {
            if lastConsonant != nil {
                closestVowel = char
            }
        }
    }

    return ""
}
```

import Foundation

func getClosestVowel(word: String) -> String {
    let vowels: Set<Character> = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var closestVowel: Character? = nil

    for i in stride(from: word.count - 2, through: 1, by: -1) {
        let currentChar = word[word.index(word.startIndex, offsetBy: i)]
        let prevChar = word[word.index(word.startIndex, offsetBy: i - 1)]
        let nextChar = word[word.index(word.startIndex, offsetBy: i + 1)]

        if vowels.contains(currentChar) && !vowels.contains(prevChar) && !vowels.contains(nextChar) {
            closestVowel = currentChar
            break
        }
    }

    return closestVowel != nil ? String(closestVowel!) : ""
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
import Foundation

func getClosestVowel(word: String) -> String {
    let vowels: Set<Character> = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    var closestVowel: Character? = nil

    for i in stride(from: word.count - 2, through: 1, by: -1) {
        let currentChar = word[word.index(word.startIndex, offsetBy: i)]
        let prevChar = word[word.index(word.startIndex, offsetBy: i - 1)]
        let nextChar = word[word.index(word.startIndex, offsetBy: i + 1)]

        if vowels.contains(currentChar) && !vowels.contains(prevChar) && !vowels.contains(nextChar) {
            closestVowel = currentChar
            break
        }
    }

    return closestVowel != nil ? String(closestVowel!) : ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false

    for char in word.reversed() {
        if vowels.contains(char) {
            if foundConsonant {
                closestVowel = String(char)
                break
            }
        } else {
            foundConsonant = true
        }
    }

    return closestVowel
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false

    for char in word.reversed() {
        if vowels.contains(char) {
            if foundConsonant {
                closestVowel = String(char)
                break
            }
        } else {
            foundConsonant = true
        }
    }

    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false

    for char in word.reversed() {
        if vowels.contains(char) {
            if foundConsonant {
                closestVowel = String(char)
                break
            }
        } else {
            foundConsonant = true
        }
    }

    return closestVowel
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false

    for char in word.reversed() {
        if vowels.contains(char) {
            if foundConsonant {
                closestVowel = String(char)
                break
            }
        } else {
            foundConsonant = true
        }
    }

    return closestVowel
}

// Test cases
print(getClosestVowel(word: "yogurt")) // Output: "u"
print(getClosestVowel(word: "FULL")) // Output: "U"
print(getClosestVowel(word: "quick")) // Output: ""
print(getClosestVowel(word: "ab")) // Output: ""
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    
    for i in (0..<word.count).reversed() {
        let char = String(word[word.index(word.startIndex, offsetBy: i)])
        if vowels.contains(char) {
            if foundVowel {
                closestVowel = char
                break
            }
        } else {
            foundVowel = true
        }
    }
    
    return closestVowel
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    
    for i in (0..<word.count).reversed() {
        let char = String(word[word.index(word.startIndex, offsetBy: i)])
        if vowels.contains(char) {
            if foundVowel {
                closestVowel = char
                break
            }
        } else {
            foundVowel = true
        }
    }
    
    return closestVowel
}

print(getClosestVowel(word: "yogurt")) // "u"
print(getClosestVowel(word: "FULL")) // "U"
print(getClosestVowel(word: "quick")) // ""
print(getClosestVowel(word: "ab")) // ""
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false
    
    for char in word.reversed() {
        if vowels.contains(char) {
            if foundConsonant {
                closestVowel = String(char)
                break
            }
        } else {
            foundConsonant = true
        }
    }
    
    return closestVowel
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false
    
    for char in word.reversed() {
        if vowels.contains(char) {
            if foundConsonant {
                closestVowel = String(char)
                break
            }
        } else {
            foundConsonant = true
        }
    }
    
    return closestVowel
}

print(getClosestVowel(word: "yogurt")) // Output: "u"
print(getClosestVowel(word: "FULL"))   // Output: "U"
print(getClosestVowel(word: "quick"))  // Output: ""
print(getClosestVowel(word: "ab"))     // Output: ""
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false
    
    for i in (0..<word.count).reversed() {
        let char = String(word[word.index(word.startIndex, offsetBy: i)])
        
        if vowels.contains(char) {
            if foundConsonant {
                closestVowel = char
                break
            }
        } else {
            foundConsonant = true
        }
    }
    
    return closestVowel
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false
    
    for i in (0..<word.count).reversed() {
        let char = String(word[word.index(word.startIndex, offsetBy: i)])
        
        if vowels.contains(char) {
            if foundConsonant {
                closestVowel = char
                break
            }
        } else {
            foundConsonant = true
        }
    }
    
    return closestVowel
}

print(getClosestVowel(word: "yogurt")) // Output: "u"
print(getClosestVowel(word: "FULL")) // Output: "U"
print(getClosestVowel(word: "quick")) // Output: ""
print(getClosestVowel(word: "ab")) // Output: ""
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false
    
    for char in word.reversed() {
        if vowels.contains(char) {
            if foundConsonant {
                closestVowel = String(char)
                break
            }
        } else {
            foundConsonant = true
        }
    }
    
    return closestVowel
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false
    
    for char in word.reversed() {
        if vowels.contains(char) {
            if foundConsonant {
                closestVowel = String(char)
                break
            }
        } else {
            foundConsonant = true
        }
    }
    
    return closestVowel
}

print(getClosestVowel(word: "yogurt")) // Output: "u"
print(getClosestVowel(word: "FULL")) // Output: "U"
print(getClosestVowel(word: "quick")) // Output: ""
print(getClosestVowel(word: "ab")) // Output: ""
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false
    
    for char in word.reversed() {
        if vowels.contains(char) {
            if foundConsonant {
                closestVowel = String(char)
                break
            }
        } else {
            foundConsonant = true
        }
    }
    
    return closestVowel
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false
    
    for char in word.reversed() {
        if vowels.contains(char) {
            if foundConsonant {
                closestVowel = String(char)
                break
            }
        } else {
            foundConsonant = true
        }
    }
    
    return closestVowel
}

print(getClosestVowel(word: "yogurt")) // Output: "u"
print(getClosestVowel(word: "FULL"))   // Output: "U"
print(getClosestVowel(word: "quick"))  // Output: ""
print(getClosestVowel(word: "ab"))     // Output: ""
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false
    
    for i in (0..<word.count).reversed() {
        let char = String(word[word.index(word.startIndex, offsetBy: i)])
        
        if vowels.contains(char) {
            if foundConsonant {
                closestVowel = char
                break
            }
        } else {
            foundConsonant = true
        }
    }
    
    return closestVowel
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false
    
    for i in (0..<word.count).reversed() {
        let char = String(word[word.index(word.startIndex, offsetBy: i)])
        
        if vowels.contains(char) {
            if foundConsonant {
                closestVowel = char
                break
            }
        } else {
            foundConsonant = true
        }
    }
    
    return closestVowel
}

print(getClosestVowel(word: "yogurt")) // Output: "u"
print(getClosestVowel(word: "FULL")) // Output: "U"
print(getClosestVowel(word: "quick")) // Output: ""
print(getClosestVowel(word: "ab")) // Output: ""
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false
    
    for char in word.reversed() {
        if vowels.contains(char) {
            if foundConsonant {
                closestVowel = String(char)
                break
            }
        } else {
            foundConsonant = true
        }
    }
    
    return closestVowel
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false
    
    for char in word.reversed() {
        if vowels.contains(char) {
            if foundConsonant {
                closestVowel = String(char)
                break
            }
        } else {
            foundConsonant = true
        }
    }
    
    return closestVowel
}

print(getClosestVowel(word: "yogurt")) // Output: "u"
print(getClosestVowel(word: "FULL"))   // Output: "U"
print(getClosestVowel(word: "quick"))  // Output: ""
print(getClosestVowel(word: "ab"))     // Output: ""
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false
    
    for char in word.reversed() {
        if vowels.contains(char) {
            if foundConsonant {
                closestVowel = String(char)
                break
            }
        } else {
            foundConsonant = true
        }
    }
    
    return closestVowel
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false
    
    for char in word.reversed() {
        if vowels.contains(char) {
            if foundConsonant {
                closestVowel = String(char)
                break
            }
        } else {
            foundConsonant = true
        }
    }
    
    return closestVowel
}

print(getClosestVowel(word: "yogurt")) // Output: "u"
print(getClosestVowel(word: "FULL")) // Output: "U"
print(getClosestVowel(word: "quick")) // Output: ""
print(getClosestVowel(word: "ab")) // Output: ""
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    let characters = Array(word)
    
    for i in (0..<characters.count).reversed() {
        if i > 0 && i < characters.count - 1 && !vowels.contains(characters[i]) && vowels.contains(characters[i - 1]) && vowels.contains(characters[i + 1]) {
            return String(characters[i])
        }
    }
    
    return ""
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    let characters = Array(word)
    
    for i in (0..<characters.count).reversed() {
        if i > 0 && i < characters.count - 1 && !vowels.contains(characters[i]) && vowels.contains(characters[i - 1]) && vowels.contains(characters[i + 1]) {
            return String(characters[i])
        }
    }
    
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false
    
    for i in (0..<word.count).reversed() {
        let char = String(word[word.index(word.startIndex, offsetBy: i)])
        
        if vowels.contains(char) {
            if foundConsonant {
                closestVowel = char
                break
            }
        } else {
            foundConsonant = true
        }
    }
    
    return closestVowel
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false
    
    for i in (0..<word.count).reversed() {
        let char = String(word[word.index(word.startIndex, offsetBy: i)])
        
        if vowels.contains(char) {
            if foundConsonant {
                closestVowel = char
                break
            }
        } else {
            foundConsonant = true
        }
    }
    
    return closestVowel
}

print(getClosestVowel(word: "yogurt")) // "u"
print(getClosestVowel(word: "FULL")) // "U"
print(getClosestVowel(word: "quick")) // ""
print(getClosestVowel(word: "ab")) // ""
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false
    
    for char in word.reversed() {
        if vowels.contains(char) {
            if foundConsonant {
                closestVowel = String(char)
                break
            }
        } else {
            foundConsonant = true
        }
    }
    
    return closestVowel
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false
    
    for char in word.reversed() {
        if vowels.contains(char) {
            if foundConsonant {
                closestVowel = String(char)
                break
            }
        } else {
            foundConsonant = true
        }
    }
    
    return closestVowel
}

print(getClosestVowel(word: "yogurt")) // Output: "u"
print(getClosestVowel(word: "FULL"))   // Output: "U"
print(getClosestVowel(word: "quick"))  // Output: ""
print(getClosestVowel(word: "ab"))     // Output: ""
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    
    for i in (0..<word.count).reversed() {
        let char = String(word[word.index(word.startIndex, offsetBy: i)])
        
        if vowels.contains(char) {
            if foundVowel {
                closestVowel = char
                break
            }
        } else {
            foundVowel = true
        }
    }
    
    return closestVowel
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    
    for i in (0..<word.count).reversed() {
        let char = String(word[word.index(word.startIndex, offsetBy: i)])
        
        if vowels.contains(char) {
            if foundVowel {
                closestVowel = char
                break
            }
        } else {
            foundVowel = true
        }
    }
    
    return closestVowel
}

print(getClosestVowel(word: "yogurt")) // "u"
print(getClosestVowel(word: "FULL")) // "U"
print(getClosestVowel(word: "quick")) // ""
print(getClosestVowel(word: "ab")) // ""
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false
    
    for char in word.reversed() {
        if vowels.contains(char) {
            if foundConsonant {
                closestVowel = String(char)
                break
            }
        } else {
            foundConsonant = true
        }
    }
    
    return closestVowel
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false
    
    for char in word.reversed() {
        if vowels.contains(char) {
            if foundConsonant {
                closestVowel = String(char)
                break
            }
        } else {
            foundConsonant = true
        }
    }
    
    return closestVowel
}

print(getClosestVowel(word: "yogurt")) // Output: "u"
print(getClosestVowel(word: "FULL")) // Output: "U"
print(getClosestVowel(word: "quick")) // Output: ""
print(getClosestVowel(word: "ab")) // Output: ""
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    let characters = Array(word)
    
    for i in (0..<characters.count).reversed() {
        if i > 0 && i < characters.count - 1 && !vowels.contains(characters[i]) && vowels.contains(characters[i - 1]) && vowels.contains(characters[i + 1]) {
            return String(characters[i])
        }
    }
    
    return ""
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    let characters = Array(word)
    
    for i in (0..<characters.count).reversed() {
        if i > 0 && i < characters.count - 1 && !vowels.contains(characters[i]) && vowels.contains(characters[i - 1]) && vowels.contains(characters[i + 1]) {
            return String(characters[i])
        }
    }
    
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false
    
    for i in (0..<word.count).reversed() {
        let char = String(word[word.index(word.startIndex, offsetBy: i)])
        
        if vowels.contains(char) {
            if foundConsonant {
                closestVowel = char
                break
            }
        } else {
            foundConsonant = true
        }
    }
    
    return closestVowel
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false
    
    for i in (0..<word.count).reversed() {
        let char = String(word[word.index(word.startIndex, offsetBy: i)])
        
        if vowels.contains(char) {
            if foundConsonant {
                closestVowel = char
                break
            }
        } else {
            foundConsonant = true
        }
    }
    
    return closestVowel
}

print(getClosestVowel(word: "yogurt")) // Output: "u"
print(getClosestVowel(word: "FULL")) // Output: "U"
print(getClosestVowel(word: "quick")) // Output: ""
print(getClosestVowel(word: "ab")) // Output: ""
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    
    for i in (0..<word.count).reversed() {
        let char = String(word[word.index(word.startIndex, offsetBy: i)])
        
        if vowels.contains(char) {
            if foundVowel {
                closestVowel = char
                break
            }
        } else {
            foundVowel = true
        }
    }
    
    return closestVowel
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    
    for i in (0..<word.count).reversed() {
        let char = String(word[word.index(word.startIndex, offsetBy: i)])
        
        if vowels.contains(char) {
            if foundVowel {
                closestVowel = char
                break
            }
        } else {
            foundVowel = true
        }
    }
    
    return closestVowel
}

print(getClosestVowel(word: "yogurt")) // Output: "u"
print(getClosestVowel(word: "FULL")) // Output: "U"
print(getClosestVowel(word: "quick")) // Output: ""
print(getClosestVowel(word: "ab")) // Output: ""
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false
    
    for i in (0..<word.count).reversed() {
        let char = String(word[word.index(word.startIndex, offsetBy: i)])
        
        if vowels.contains(char) {
            if foundConsonant {
                closestVowel = char
                break
            }
        } else {
            foundConsonant = true
        }
    }
    
    return closestVowel
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false
    
    for i in (0..<word.count).reversed() {
        let char = String(word[word.index(word.startIndex, offsetBy: i)])
        
        if vowels.contains(char) {
            if foundConsonant {
                closestVowel = char
                break
            }
        } else {
            foundConsonant = true
        }
    }
    
    return closestVowel
}

print(getClosestVowel(word: "yogurt")) // Output: "u"
print(getClosestVowel(word: "FULL"))   // Output: "U"
print(getClosestVowel(word: "quick"))  // Output: ""
print(getClosestVowel(word: "ab"))     // Output: ""
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false
    
    for i in (0..<word.count).reversed() {
        let char = String(word[word.index(word.startIndex, offsetBy: i)])
        if vowels.contains(char) {
            if foundConsonant {
                closestVowel = char
                break
            }
        } else {
            foundConsonant = true
        }
    }
    
    return closestVowel
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundConsonant = false
    
    for i in (0..<word.count).reversed() {
        let char = String(word[word.index(word.startIndex, offsetBy: i)])
        if vowels.contains(char) {
            if foundConsonant {
                closestVowel = char
                break
            }
        } else {
            foundConsonant = true
        }
    }
    
    return closestVowel
}

print(getClosestVowel(word: "yogurt")) // Output: "u"
print(getClosestVowel(word: "FULL")) // Output: "U"
print(getClosestVowel(word: "quick")) // Output: ""
print(getClosestVowel(word: "ab")) // Output: ""
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var closestVowelIndex = word.count
    
    for (index, letter) in word.enumerated() {
        if vowels.contains(String(letter)) {
            let vowelIndex = word.index(word.startIndex, offsetBy: index)
            let nextVowelIndex = word.index(word.startIndex, offsetBy: index + 1)
            
            if word[nextVowelIndex].isLetter {
                let nextVowel = String(word[nextVowelIndex])
                if vowels.contains(nextVowel) {
                    closestVowel = nextVowel
                    closestVowelIndex = index + 1
                }
            }
        }
    }
    
    if closestVowelIndex == word.count {
        return ""
    }
    
    return closestVowel
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var closestVowelIndex = word.count
    
    for (index, letter) in word.enumerated() {
        if vowels.contains(String(letter)) {
            let vowelIndex = word.index(word.startIndex, offsetBy: index)
            let nextVowelIndex = word.index(word.startIndex, offsetBy: index + 1)
            
            if word[nextVowelIndex].isLetter {
                let nextVowel = String(word[nextVowelIndex])
                if vowels.contains(nextVowel) {
                    closestVowel = nextVowel
                    closestVowelIndex = index + 1
                }
            }
        }
    }
    
    if closestVowelIndex == word.count {
        return ""
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    
    let vowels = "aeiouAEIOU"
    let consonants = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
    
    var charArray = Array(word)
    
    for i in 0..<charArray.count {
        
        if vowels.contains(charArray[i]) {
            
            if consonants.contains(charArray[i-1]) && consonants.contains(charArray[i+1]) {
                
                return String(charArray[i])
            }
        }
    }
    
    return ""
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    
    let vowels = "aeiouAEIOU"
    let consonants = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
    
    var charArray = Array(word)
    
    for i in 0..<charArray.count {
        
        if vowels.contains(charArray[i]) {
            
            if consonants.contains(charArray[i-1]) && consonants.contains(charArray[i+1]) {
                
                return String(charArray[i])
            }
        }
    }
    
    return ""
}
```

func getClosestVowel(word: String) -> String {
    
    let vowels = "aeiouAEIOU"
    let consonants = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
    
    var closestVowel = ""
    
    for (index, char) in word.enumerated() {
        if consonants.contains(char) {
            for (index2, char2) in word.enumerated() {
                if vowels.contains(char2) && index2 > index {
                    closestVowel = String(char2)
                }
            }
        }
    }
    
    return closestVowel
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    
    let vowels = "aeiouAEIOU"
    let consonants = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
    
    var closestVowel = ""
    
    for (index, char) in word.enumerated() {
        if consonants.contains(char) {
            for (index2, char2) in word.enumerated() {
                if vowels.contains(char2) && index2 > index {
                    closestVowel = String(char2)
                }
            }
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    
    var vowels = "aeiouAEIOU"
    var consonants = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
    var vowelsArray = [Character]()
    var consonantsArray = [Character]()
    var closestVowel = ""
    
    for char in word {
        if vowels.contains(char) {
            vowelsArray.append(char)
        } else if consonants.contains(char) {
            consonantsArray.append(char)
        }
    }
    
    for (index, char) in consonantsArray.enumerated() {
        if index < consonantsArray.count - 1 {
            if consonantsArray[index + 1] == vowelsArray[0] {
                closestVowel = String(vowelsArray[0])
            }
        }
    }
    
    return closestVowel
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    
    var vowels = "aeiouAEIOU"
    var consonants = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
    var vowelsArray = [Character]()
    var consonantsArray = [Character]()
    var closestVowel = ""
    
    for char in word {
        if vowels.contains(char) {
            vowelsArray.append(char)
        } else if consonants.contains(char) {
            consonantsArray.append(char)
        }
    }
    
    for (index, char) in consonantsArray.enumerated() {
        if index < consonantsArray.count - 1 {
            if consonantsArray[index + 1] == vowelsArray[0] {
                closestVowel = String(vowelsArray[0])
            }
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    let consonants = "bcdfghjklmnpqrstvwxyz"
    let wordArray = Array(word)
    var vowelIndex = 0
    var consonantIndex = 0
    var closestVowel = ""
    
    for (index, letter) in wordArray.enumerated() {
        if consonants.contains(letter) {
            consonantIndex = index
        }
        if vowels.contains(letter) {
            vowelIndex = index
        }
    }
    
    for (index, letter) in wordArray.enumerated() {
        if vowels.contains(letter) {
            if index > consonantIndex && index < vowelIndex {
                closestVowel = String(letter)
            }
        }
    }
    
    return closestVowel
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    let consonants = "bcdfghjklmnpqrstvwxyz"
    let wordArray = Array(word)
    var vowelIndex = 0
    var consonantIndex = 0
    var closestVowel = ""
    
    for (index, letter) in wordArray.enumerated() {
        if consonants.contains(letter) {
            consonantIndex = index
        }
        if vowels.contains(letter) {
            vowelIndex = index
        }
    }
    
    for (index, letter) in wordArray.enumerated() {
        if vowels.contains(letter) {
            if index > consonantIndex && index < vowelIndex {
                closestVowel = String(letter)
            }
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    let consonants = "bcdfghjklmnpqrstvwxyz"
    
    var vowelsArray = [String]()
    var consonantsArray = [String]()
    
    for (index, char) in word.enumerated() {
        if vowels.contains(char) {
            vowelsArray.append(String(char))
        }
        
        if consonants.contains(char) {
            consonantsArray.append(String(char))
        }
    }
    
    if vowelsArray.count == 0 || consonantsArray.count == 0 {
        return ""
    }
    
    let lastVowel = vowelsArray.last!
    let lastConsonant = consonantsArray.last!
    
    let lastVowelIndex = word.index(word.endIndex, offsetBy: -1)
    let lastConsonantIndex = word.index(word.endIndex, offsetBy: -1)
    
    let distance = word.distance(from: lastVowelIndex, to: lastConsonantIndex)
    
    if distance == 1 {
        return lastVowel
    } else {
        return ""
    }
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    let consonants = "bcdfghjklmnpqrstvwxyz"
    
    var vowelsArray = [String]()
    var consonantsArray = [String]()
    
    for (index, char) in word.enumerated() {
        if vowels.contains(char) {
            vowelsArray.append(String(char))
        }
        
        if consonants.contains(char) {
            consonantsArray.append(String(char))
        }
    }
    
    if vowelsArray.count == 0 || consonantsArray.count == 0 {
        return ""
    }
    
    let lastVowel = vowelsArray.last!
    let lastConsonant = consonantsArray.last!
    
    let lastVowelIndex = word.index(word.endIndex, offsetBy: -1)
    let lastConsonantIndex = word.index(word.endIndex, offsetBy: -1)
    
    let distance = word.distance(from: lastVowelIndex, to: lastConsonantIndex)
    
    if distance == 1 {
        return lastVowel
    } else {
        return ""
    }
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    let consonants = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
    
    for i in (0..<word.count).reversed() {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if consonants.contains(char) {
            for j in (0..<word.count).reversed() {
                let char2 = word[word.index(word.startIndex, offsetBy: j)]
                if vowels.contains(char2) {
                    return String(char2)
                }
            }
        }
    }
    return ""
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    let consonants = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
    
    for i in (0..<word.count).reversed() {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if consonants.contains(char) {
            for j in (0..<word.count).reversed() {
                let char2 = word[word.index(word.startIndex, offsetBy: j)]
                if vowels.contains(char2) {
                    return String(char2)
                }
            }
        }
    }
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    let consonants = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
    var closestVowel = ""
    var closestVowelIndex = 0
    var isVowel = false
    var isConsonant = false
    var isVowelFound = false
    var isConsonantFound = false
    var isVowelFoundFirst = false
    var isConsonantFoundFirst = false
    
    for (index, char) in word.enumerated() {
        if vowels.contains(char) {
            isVowel = true
            isVowelFound = true
            isVowelFoundFirst = true
            if isConsonantFoundFirst {
                closestVowel = String(char)
                closestVowelIndex = index
            }
        }
        
        if consonants.contains(char) {
            isConsonant = true
            isConsonantFound = true
            isConsonantFoundFirst = true
            if isVowelFoundFirst {
                closestVowel = String(char)
                closestVowelIndex = index
            }
        }
        
        if isVowel && isConsonant {
            if index > closestVowelIndex {
                closestVowel = String(char)
                closestVowelIndex = index
            }
        }
        
        if isVowel && !isConsonant {
            isVowel = false
        }
        
        if !isVowel && isConsonant {
            isConsonant = false
        }
    }
    
    return closestVowel
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    let consonants = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
    var closestVowel = ""
    var closestVowelIndex = 0
    var isVowel = false
    var isConsonant = false
    var isVowelFound = false
    var isConsonantFound = false
    var isVowelFoundFirst = false
    var isConsonantFoundFirst = false
    
    for (index, char) in word.enumerated() {
        if vowels.contains(char) {
            isVowel = true
            isVowelFound = true
            isVowelFoundFirst = true
            if isConsonantFoundFirst {
                closestVowel = String(char)
                closestVowelIndex = index
            }
        }
        
        if consonants.contains(char) {
            isConsonant = true
            isConsonantFound = true
            isConsonantFoundFirst = true
            if isVowelFoundFirst {
                closestVowel = String(char)
                closestVowelIndex = index
            }
        }
        
        if isVowel && isConsonant {
            if index > closestVowelIndex {
                closestVowel = String(char)
                closestVowelIndex = index
            }
        }
        
        if isVowel && !isConsonant {
            isVowel = false
        }
        
        if !isVowel && isConsonant {
            isConsonant = false
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var closestVowel = ""
    var closestVowelIndex = 0
    var wordArray = Array(word)
    
    for (index, char) in wordArray.reversed().enumerated() {
        if consonants.contains(String(char)) {
            if vowels.contains(String(wordArray[index + 1])) {
                closestVowel = String(wordArray[index + 1])
                closestVowelIndex = index + 1
            }
        }
    }
    
    if closestVowelIndex == 0 {
        return ""
    } else {
        return closestVowel
    }
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var closestVowel = ""
    var closestVowelIndex = 0
    var wordArray = Array(word)
    
    for (index, char) in wordArray.reversed().enumerated() {
        if consonants.contains(String(char)) {
            if vowels.contains(String(wordArray[index + 1])) {
                closestVowel = String(wordArray[index + 1])
                closestVowelIndex = index + 1
            }
        }
    }
    
    if closestVowelIndex == 0 {
        return ""
    } else {
        return closestVowel
    }
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var vowel = ""
    var isVowel = false
    for i in word.indices {
        let char = String(word[i])
        if consonants.contains(char) {
            if isVowel {
                vowel = char
                isVowel = false
            }
        } else if vowels.contains(char) {
            isVowel = true
        }
    }
    return vowel
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var vowel = ""
    var isVowel = false
    for i in word.indices {
        let char = String(word[i])
        if consonants.contains(char) {
            if isVowel {
                vowel = char
                isVowel = false
            }
        } else if vowels.contains(char) {
            isVowel = true
        }
    }
    return vowel
}
```

func getClosestVowel(word: String) -> String {
    // TODO: implement me
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    // TODO: implement me
}
```

func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var vowel = ""
    var index = 0
    
    for i in word.characters.enumerated() {
        if i.offset == 0 || i.offset == word.characters.count - 1 {
            continue
        }
        
        if vowels.contains(String(i.element)) {
            vowel = String(i.element)
            index = i.offset
            break
        }
    }
    
    return vowel
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var vowel = ""
    var index = 0
    
    for i in word.characters.enumerated() {
        if i.offset == 0 || i.offset == word.characters.count - 1 {
            continue
        }
        
        if vowels.contains(String(i.element)) {
            vowel = String(i.element)
            index = i.offset
            break
        }
    }
    
    return vowel
}
```

func getClosestVowel(word: String) -> String {
    // TODO: implement me
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    // TODO: implement me
}
```

func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var index = 0
    var isVowel = false
    var isConsonant = false
    for i in word.characters.enumerated() {
        if vowels.contains(i.element) {
            isVowel = true
        } else {
            if isVowel {
                result = i.element
                index = i.index
                break
            } else {
                isVowel = false
                isConsonant = true
            }
        }
    }
    if isConsonant {
        for i in word.characters.enumerated() {
            if i.index > index {
                if vowels.contains(i.element) {
                    result = i.element
                    break
                }
            }
        }
    }
    return result
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var index = 0
    var isVowel = false
    var isConsonant = false
    for i in word.characters.enumerated() {
        if vowels.contains(i.element) {
            isVowel = true
        } else {
            if isVowel {
                result = i.element
                index = i.index
                break
            } else {
                isVowel = false
                isConsonant = true
            }
        }
    }
    if isConsonant {
        for i in word.characters.enumerated() {
            if i.index > index {
                if vowels.contains(i.element) {
                    result = i.element
                    break
                }
            }
        }
    }
    return result
}
```

func getClosestVowel(word: String) -> String {
    // TODO: implement
    return ""
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    // TODO: implement
    return ""
}
```

func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var index = 0
    var wordLength = word.characters.count
    
    while index < wordLength {
        if vowels.contains(word[index]) {
            if index == 0 || index == wordLength - 1 {
                index += 1
            } else {
                result = word[index]
                break
            }
        } else {
            index += 1
        }
    }
    
    return result
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var index = 0
    var wordLength = word.characters.count
    
    while index < wordLength {
        if vowels.contains(word[index]) {
            if index == 0 || index == wordLength - 1 {
                index += 1
            } else {
                result = word[index]
                break
            }
        } else {
            index += 1
        }
    }
    
    return result
}
```

func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var i = 0
    var j = word.characters.count - 1
    while i < j {
        if vowels.contains(word[i]) {
            if vowels.contains(word[j]) {
                result = word[j]
                break
            } else {
                result = word[i]
                break
            }
        }
        i += 1
        j -= 1
    }
    return result
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var i = 0
    var j = word.characters.count - 1
    while i < j {
        if vowels.contains(word[i]) {
            if vowels.contains(word[j]) {
                result = word[j]
                break
            } else {
                result = word[i]
                break
            }
        }
        i += 1
        j -= 1
    }
    return result
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var vowel = ""
    var lastConsonant = ""
    var lastVowel = ""
    
    for char in word {
        if vowels.contains(char) {
            lastVowel = char
        } else {
            lastConsonant = char
        }
    }
    
    if lastConsonant!= "" && lastVowel!= "" {
        let vowelIndex = vowels.index(of: lastVowel)
        let vowelIndexFromRight = vowels.count - vowelIndex - 1
        let closestVowelIndex = vowels.count - vowelIndexFromRight - 1
        vowel = vowels[closestVowelIndex]
    }
    
    return vowel
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var vowel = ""
    var lastConsonant = ""
    var lastVowel = ""
    
    for char in word {
        if vowels.contains(char) {
            lastVowel = char
        } else {
            lastConsonant = char
        }
    }
    
    if lastConsonant!= "" && lastVowel!= "" {
        let vowelIndex = vowels.index(of: lastVowel)
        let vowelIndexFromRight = vowels.count - vowelIndex - 1
        let closestVowelIndex = vowels.count - vowelIndexFromRight - 1
        vowel = vowels[closestVowelIndex]
    }
    
    return vowel
}
```

func getClosestVowel(word: String) -> String {
    var vowels = "aeiouAEIOU"
    var result = ""
    var lastConsonant = ""
    var lastVowel = ""
    
    for i in word.characters.enumerated() {
        if vowels.contains(String(i.element)) {
            lastVowel = String(i.element)
        } else {
            lastConsonant = String(i.element)
        }
    }
    
    if lastConsonant.isEmpty || lastVowel.isEmpty {
        return result
    }
    
    for i in word.characters.enumerated() {
        if vowels.contains(String(i.element)) {
            if lastConsonant.distance(from: lastVowel) < i.element.distance(from: lastVowel) {
                result = String(i.element)
            }
        }
    }
    
    return result
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowels = "aeiouAEIOU"
    var result = ""
    var lastConsonant = ""
    var lastVowel = ""
    
    for i in word.characters.enumerated() {
        if vowels.contains(String(i.element)) {
            lastVowel = String(i.element)
        } else {
            lastConsonant = String(i.element)
        }
    }
    
    if lastConsonant.isEmpty || lastVowel.isEmpty {
        return result
    }
    
    for i in word.characters.enumerated() {
        if vowels.contains(String(i.element)) {
            if lastConsonant.distance(from: lastVowel) < i.element.distance(from: lastVowel) {
                result = String(i.element)
            }
        }
    }
    
    return result
}
```

func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var index = 0
    var wordLength = word.characters.count
    
    for i in 0..<wordLength {
        if i == 0 {
            continue
        }
        
        if word[i] == "a" || word[i] == "e" || word[i] == "i" || word[i] == "o" || word[i] == "u" {
            if word[i-1]!= "a" && word[i-1]!= "e" && word[i-1]!= "i" && word[i-1]!= "o" && word[i-1]!= "u" {
                result = word[i]
                index = i
                break
            }
        }
    }
    
    if result == "" {
        return ""
    }
    
    return word[index..<wordLength]
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var index = 0
    var wordLength = word.characters.count
    
    for i in 0..<wordLength {
        if i == 0 {
            continue
        }
        
        if word[i] == "a" || word[i] == "e" || word[i] == "i" || word[i] == "o" || word[i] == "u" {
            if word[i-1]!= "a" && word[i-1]!= "e" && word[i-1]!= "i" && word[i-1]!= "o" && word[i-1]!= "u" {
                result = word[i]
                index = i
                break
            }
        }
    }
    
    if result == "" {
        return ""
    }
    
    return word[index..<wordLength]
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "AEIOUaeiou"
    var closestVowel = ""
    
    for char in word.reversed() {
        if vowels.contains(char) &&!vowels.contains(String(char).prefix(1)) {
            closestVowel = String(char)
            break
        }
    }
    
    return closestVowel
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "AEIOUaeiou"
    var closestVowel = ""
    
    for char in word.reversed() {
        if vowels.contains(char) &&!vowels.contains(String(char).prefix(1)) {
            closestVowel = String(char)
            break
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "AEIOUaeiou"
    var closestVowel = ""
    var index = word.index(before: word.endIndex)
    
    while index!= word.startIndex {
        if vowels.contains(String(word[index])) {
            closestVowel = String(word[index])
            break
        }
        index = word.index(before: index)
    }
    
    if closestVowel.isEmpty {
        return ""
    }
    
    while index!= word.startIndex {
        let previousChar = String(word[index])
        if previousChar.isUppercase &&!vowels.contains(previousChar) {
            closestVowel = previousChar
            break
        }
        index = word.index(before: index)
    }
    
    return closestVowel
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "AEIOUaeiou"
    var closestVowel = ""
    var index = word.index(before: word.endIndex)
    
    while index!= word.startIndex {
        if vowels.contains(String(word[index])) {
            closestVowel = String(word[index])
            break
        }
        index = word.index(before: index)
    }
    
    if closestVowel.isEmpty {
        return ""
    }
    
    while index!= word.startIndex {
        let previousChar = String(word[index])
        if previousChar.isUppercase &&!vowels.contains(previousChar) {
            closestVowel = previousChar
            break
        }
        index = word.index(before: index)
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "AEIOUaeiou"
    var closestVowel = ""
    
    for char in word.reversed() {
        if vowels.contains(char) &&!vowels.contains(String(char).prefix(1)) {
            closestVowel = String(char).lowercased()
            break
        }
    }
    
    return closestVowel
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "AEIOUaeiou"
    var closestVowel = ""
    
    for char in word.reversed() {
        if vowels.contains(char) &&!vowels.contains(String(char).prefix(1)) {
            closestVowel = String(char).lowercased()
            break
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "AEIOUaeiou"
    var closestVowel = ""
    
    for char in word.reversed() {
        if vowels.contains(char) &&!vowels.contains(String(char).prefix(1)) {
            closestVowel = String(char)
            break
        }
    }
    
    return closestVowel
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "AEIOUaeiou"
    var closestVowel = ""
    
    for char in word.reversed() {
        if vowels.contains(char) &&!vowels.contains(String(char).prefix(1)) {
            closestVowel = String(char)
            break
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = CharacterSet(charactersIn: "aeiouAEIOU")
    var closestVowel = ""
    var index = word.index(before: word.endIndex)

    while index!= word.startIndex {
        if vowels.contains(word[index]) {
            closestVowel = String(word[index])
            break
        }
        index = word.index(before: index)
    }

    if closestVowel.isEmpty {
        return ""
    }

    let consonants = CharacterSet(charactersIn: "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ")
    while index!= word.startIndex {
        if consonants.contains(word[index]) {
            return closestVowel
        }
        index = word.index(before: index)
    }

    return ""
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {
    let vowels = CharacterSet(charactersIn: "aeiouAEIOU")
    var closestVowel = ""
    var index = word.index(before: word.endIndex)

    while index!= word.startIndex {
        if vowels.contains(word[index]) {
            closestVowel = String(word[index])
            break
        }
        index = word.index(before: index)
    }

    if closestVowel.isEmpty {
        return ""
    }

    let consonants = CharacterSet(charactersIn: "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ")
    while index!= word.startIndex {
        if consonants.contains(word[index]) {
            return closestVowel
        }
        index = word.index(before: index)
    }

    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = CharacterSet(charactersIn: "aeiouAEIOU")
    var closestVowel = ""
    var index = word.index(before: word.endIndex)

    while index!= word.startIndex {
        if vowels.contains(word[index]) {
            closestVowel = String(word[index])
            break
        }
        index = word.index(before: index)
    }

    if closestVowel.isEmpty {
        return ""
    }

    let consonants = CharacterSet(charactersIn: "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ")
    while index!= word.startIndex {
        if consonants.contains(word[index]) {
            return closestVowel
        }
        index = word.index(before: index)
    }

    return ""
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {
    let vowels = CharacterSet(charactersIn: "aeiouAEIOU")
    var closestVowel = ""
    var index = word.index(before: word.endIndex)

    while index!= word.startIndex {
        if vowels.contains(word[index]) {
            closestVowel = String(word[index])
            break
        }
        index = word.index(before: index)
    }

    if closestVowel.isEmpty {
        return ""
    }

    let consonants = CharacterSet(charactersIn: "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ")
    while index!= word.startIndex {
        if consonants.contains(word[index]) {
            return closestVowel
        }
        index = word.index(before: index)
    }

    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = CharacterSet(charactersIn: "aeiouAEIOU")
    var closestVowel = ""
    var index = word.index(before: word.endIndex)

    while index!= word.startIndex {
        if vowels.contains(word[index]) {
            closestVowel = String(word[index])
            break
        }
        index = word.index(before: index)
    }

    if closestVowel.isEmpty {
        return ""
    }

    let consonants = CharacterSet(charactersIn: "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ")
    while index!= word.startIndex {
        if consonants.contains(word[index]) {
            return closestVowel
        }
        index = word.index(before: index)
    }

    return ""
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {
    let vowels = CharacterSet(charactersIn: "aeiouAEIOU")
    var closestVowel = ""
    var index = word.index(before: word.endIndex)

    while index!= word.startIndex {
        if vowels.contains(word[index]) {
            closestVowel = String(word[index])
            break
        }
        index = word.index(before: index)
    }

    if closestVowel.isEmpty {
        return ""
    }

    let consonants = CharacterSet(charactersIn: "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ")
    while index!= word.startIndex {
        if consonants.contains(word[index]) {
            return closestVowel
        }
        index = word.index(before: index)
    }

    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "AEIOUaeiou"
    var closestVowel = ""
    
    for char in word.reversed() {
        if vowels.contains(char) &&!vowels.contains(String(char).prefix(1)) {
            closestVowel = String(char)
            break
        }
    }
    
    return closestVowel
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "AEIOUaeiou"
    var closestVowel = ""
    
    for char in word.reversed() {
        if vowels.contains(char) &&!vowels.contains(String(char).prefix(1)) {
            closestVowel = String(char)
            break
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "AEIOUaeiou"
    var closestVowel = ""
    
    if word.isEmpty ||!word.contains(where: { vowels.contains($0) }) {
        return ""
    }
    
    var index = word.index(before: word.endIndex)
    while index!= word.startIndex {
        let character = String(word[index])
        if vowels.contains(character) {
            closestVowel = character
            break
        }
        index = word.index(before: index)
    }
    
    return closestVowel
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "AEIOUaeiou"
    var closestVowel = ""
    
    if word.isEmpty ||!word.contains(where: { vowels.contains($0) }) {
        return ""
    }
    
    var index = word.index(before: word.endIndex)
    while index!= word.startIndex {
        let character = String(word[index])
        if vowels.contains(character) {
            closestVowel = character
            break
        }
        index = word.index(before: index)
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "AEIOUaeiou"
    var closestVowel = ""
    var index = word.index(before: word.endIndex)
    
    while index > word.startIndex {
        if vowels.contains(String(word[index])) {
            closestVowel = String(word[index])
            break
        }
        index = word.index(before: index)
    }
    
    return closestVowel
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<|im_end|>
<|im_start|>assistant
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "AEIOUaeiou"
    var closestVowel = ""
    var index = word.index(before: word.endIndex)
    
    while index > word.startIndex {
        if vowels.contains(String(word[index])) {
            closestVowel = String(word[index])
            break
        }
        index = word.index(before: index)
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    var result = ""
    for i in 0..<word.count-1 {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if char.isVowel {
            result = word[word.index(word.startIndex, offsetBy: i+1)]
            break
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    var result = ""
    for i in 0..<word.count-1 {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if char.isVowel {
            result = word[word.index(word.startIndex, offsetBy: i+1)]
            break
        }
    }
    return result
}
```

func getClosestVowel(word: String) -> String {
    var result = ""
    var isVowel = false
    for i in 0..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if char == "a" || char == "e" || char == "i" || char == "o" || char == "u" {
            result = char
            isVowel = true
        } else if isVowel {
            break
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    var result = ""
    var isVowel = false
    for i in 0..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if char == "a" || char == "e" || char == "i" || char == "o" || char == "u" {
            result = char
            isVowel = true
        } else if isVowel {
            break
        }
    }
    return result
}
```
### Challenge

func getClosestVowel(word: String) -> String {
    var vowel = ""
    var i = word.count - 1
    while i >= 0 {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if char == "a" || char == "e" || char == "i" || char == "o" || char == "u" {
            vowel = char
            break
        }
        i -= 1
    }
    return vowel
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    var vowel = ""
    var i = word.count - 1
    while i >= 0 {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if char == "a" || char == "e" || char == "i" || char == "o" || char == "u" {
            vowel = char
            break
        }
        i -= 1
    }
    return vowel
}
```

func getClosestVowel(word: String) -> String {
    var vowel = ""
    var i = 0
    while i < word.count - 1 {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if char.isVowel {
            vowel = char
            break
        }
        i += 1
    }
    return vowel
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    var vowel = ""
    var i = 0
    while i < word.count - 1 {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if char.isVowel {
            vowel = char
            break
        }
        i += 1
    }
    return vowel
}
```
### Challenge

func getClosestVowel(word: String) -> String {
    var closestVowel = ""
    var isFound = false
    for i in 0..<word.count-1 {
        let currentChar = word[word.index(word.startIndex, offsetBy: i)]
        if currentChar.isVowel {
            closestVowel = currentChar.description
            isFound = true
            break
        }
    }
    if !isFound {
        return ""
    }
    return closestVowel
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    var closestVowel = ""
    var isFound = false
    for i in 0..<word.count-1 {
        let currentChar = word[word.index(word.startIndex, offsetBy: i)]
        if currentChar.isVowel {
            closestVowel = currentChar.description
            isFound = true
            break
        }
    }
    if !isFound {
        return ""
    }
    return closestVowel
}
```
### Ex

func getClosestVowel(word: String) -> String {
    var closestVowel = ""
    var isFound = false
    for i in 0..<word.count-1 {
        if word[i] == "a" || word[i] == "e" || word[i] == "i" || word[i] == "o" || word[i] == "u" {
            closestVowel = word[i]
            isFound = true
            break
        }
    }
    if !isFound {
        return ""
    } else {
        return closestVowel
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    var closestVowel = ""
    var isFound = false
    for i in 0..<word.count-1 {
        if word[i] == "a" || word[i] == "e" || word[i] == "i" || word[i] == "o" || word[i] == "u" {
            closestVowel = word[i]
            isFound = true
            break
        }
    }
    if !isFound {
        return ""
    } else {
        return closestVowel
    }
}
```

func getClosestVowel(word: String) -> String {
    var vowel = ""
    for i in 0..<word.count-1 {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if char == "a" || char == "e" || char == "i" || char == "o" || char == "u" {
            vowel = char
            break
        }
    }
    return vowel
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    var vowel = ""
    for i in 0..<word.count-1 {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if char == "a" || char == "e" || char == "i" || char == "o" || char == "u" {
            vowel = char
            break
        }
    }
    return vowel
}
```

func getClosestVowel(word: String) -> String {
    var vowel = ""
    var consonant = ""
    var index = 0
    for char in word {
        if char.isVowel {
            vowel = String(char)
            index = word.index(of: char)
            break
        }
    }
    if vowel == "" {
        return ""
    }
    for char in word.suffix(from: index + 1) {
        if char.isConsonant {
            consonant = String(char)
            break
        }
    }
    return vowel
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    var vowel = ""
    var consonant = ""
    var index = 0
    for char in word {
        if char.isVowel {
            vowel = String(char)
            index = word.index(of: char)
            break
        }
    }
    if vowel == "" {
        return ""
    }
    for char in word.suffix(from: index + 1) {
        if char.isConsonant {
            consonant = String(char)
            break
        }
    }
    return vowel
}
```
### Ex

func getClosestVowel(word: String) -> String {
    var closestVowel = ""
    var isFound = false
    for i in 0..<word.count-1 {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if char.isVowel {
            closestVowel = char.description
            isFound = true
            break
        }
    }
    return isFound ? closestVowel : ""
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    var closestVowel = ""
    var isFound = false
    for i in 0..<word.count-1 {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if char.isVowel {
            closestVowel = char.description
            isFound = true
            break
        }
    }
    return isFound ? closestVowel : ""
}
```
### Problem

func getClosestVowel(word: String) -> String {
    var closestVowel = ""
    var vowelFound = false
    for i in stride(from: word.count - 2, through: 0, by: -1) {
        if word[word.index(word.startIndex, offsetBy: i)] == "a" ||
            word[word.index(word.startIndex, offsetBy: i)] == "e" ||
            word[word.index(word.startIndex, offsetBy: i)] == "i" ||
            word[word.index(word.startIndex, offsetBy: i)] == "o" ||
            word[word.index(word.startIndex, offsetBy: i)] == "u" {
            closestVowel = word[word.index(word.startIndex, offsetBy: i)]
            vowelFound = true
            break
        }
    }
    if vowelFound {
        return closestVowel
    } else {
        return ""
    }
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    var closestVowel = ""
    var vowelFound = false
    for i in stride(from: word.count - 2, through: 0, by: -1) {
        if word[word.index(word.startIndex, offsetBy: i)] == "a" ||
            word[word.index(word.startIndex, offsetBy: i)] == "e" ||
            word[word.index(word.startIndex, offsetBy: i)] == "i" ||
            word[word.index(word.startIndex, offsetBy: i)] == "o" ||
            word[word.index(word.startIndex, offsetBy: i)] == "u" {
            closestVowel = word[word.index(word.startIndex, offsetBy: i)]
            vowelFound = true
            break
        }
    }
    if vowelFound {
        return closestVowel
    } else {
        return ""
    }
}
```
### Challenge

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var closestVowel = ""
    var closestVowelIndex = -1
    var closestVowelDistance = Int.max
    var currentDistance = 0
    for (index, letter) in word.enumerated() {
        if consonants.contains(letter) {
            if closestVowelIndex != -1 {
                currentDistance = index - closestVowelIndex
                if currentDistance < closestVowelDistance {
                    closestVowelDistance = currentDistance
                    closestVowel = word[closestVowelIndex]
                }
            }
            closestVowelIndex = index
        }
        if vowels.contains(letter) {
            closestVowelIndex = index
        }
    }
    return closestVowel
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var closestVowel = ""
    var closestVowelIndex = -1
    var closestVowelDistance = Int.max
    var currentDistance = 0
    for (index, letter) in word.enumerated() {
        if consonants.contains(letter) {
            if closestVowelIndex != -1 {
                currentDistance = index - closestVowelIndex
                if currentDistance < closestVowelDistance {
                    closestVowelDistance = currentDistance
                    closestVowel = word[closestVowelIndex]
                }
            }
            closestVowelIndex = index
        }
        if vowels.contains(letter) {
            closestVowelIndex = index
        }
    }
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    var vowel = ""
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    let wordArray = Array(word)
    for i in 0..<wordArray.count {
        if vowels.contains(String(wordArray[i])) {
            if i > 0 && i < wordArray.count - 1 {
                if consonants.contains(String(wordArray[i - 1])) && consonants.contains(String(wordArray[i + 1])) {
                    vowel = String(wordArray[i])
                }
            }
        }
    }
    return vowel
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    var vowel = ""
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    let wordArray = Array(word)
    for i in 0..<wordArray.count {
        if vowels.contains(String(wordArray[i])) {
            if i > 0 && i < wordArray.count - 1 {
                if consonants.contains(String(wordArray[i - 1])) && consonants.contains(String(wordArray[i + 1])) {
                    vowel = String(wordArray[i])
                }
            }
        }
    }
    return vowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    for i in 0..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(String(char)) {
            if i > 0 && i < word.count - 1 {
                closestVowel = String(char)
            }
        }
    }
    return closestVowel
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    for i in 0..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(String(char)) {
            if i > 0 && i < word.count - 1 {
                closestVowel = String(char)
            }
        }
    }
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var closestDistance = Int.max
    for i in 0..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(String(char)) {
            let distance = word.count - i
            if distance < closestDistance {
                closestDistance = distance
                closestVowel = String(char)
            }
        }
    }
    return closestVowel
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var closestDistance = Int.max
    for i in 0..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(String(char)) {
            let distance = word.count - i
            if distance < closestDistance {
                closestDistance = distance
                closestVowel = String(char)
            }
        }
    }
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var closestDistance = Int.max
    for i in 0..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(String(char)) {
            let distance = word.count - i
            if distance < closestDistance {
                closestDistance = distance
                closestVowel = String(char)
            }
        }
    }
    return closestVowel
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var closestDistance = Int.max
    for i in 0..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(String(char)) {
            let distance = word.count - i
            if distance < closestDistance {
                closestDistance = distance
                closestVowel = String(char)
            }
        }
    }
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var closestDistance = Int.max
    for i in 0..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(String(char)) {
            if i > 0 && i < word.count - 1 {
                let distance = word.count - i
                if distance < closestDistance {
                    closestDistance = distance
                    closestVowel = String(char)
                }
            }
        }
    }
    return closestVowel
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var closestDistance = Int.max
    for i in 0..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(String(char)) {
            if i > 0 && i < word.count - 1 {
                let distance = word.count - i
                if distance < closestDistance {
                    closestDistance = distance
                    closestVowel = String(char)
                }
            }
        }
    }
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var closestDistance = Int.max
    var currentDistance = 0
    for i in 0..<word.count {
        if vowels.contains(word[i]) {
            currentDistance = word.count - i
            if currentDistance < closestDistance {
                closestDistance = currentDistance
                closestVowel = String(word[i])
            }
        }
    }
    return closestVowel
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var closestDistance = Int.max
    var currentDistance = 0
    for i in 0..<word.count {
        if vowels.contains(word[i]) {
            currentDistance = word.count - i
            if currentDistance < closestDistance {
                closestDistance = currentDistance
                closestVowel = String(word[i])
            }
        }
    }
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    for i in 1..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(String(char)) {
            closestVowel = String(char)
            break
        }
    }
    return closestVowel
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    for i in 1..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(String(char)) {
            closestVowel = String(char)
            break
        }
    }
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var closestDistance = Int.max
    for i in 0..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(String(char)) {
            let distance = word.count - i
            if distance < closestDistance {
                closestDistance = distance
                closestVowel = String(char)
            }
        }
    }
    return closestVowel
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var closestDistance = Int.max
    for i in 0..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(String(char)) {
            let distance = word.count - i
            if distance < closestDistance {
                closestDistance = distance
                closestVowel = String(char)
            }
        }
    }
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var previousChar = ""
    var currentChar = ""
    var nextChar = ""
    var isVowelFound = false
    
    for i in 0..<word.count {
        previousChar = i > 0 ? String(word[word.index(word.startIndex, offsetBy: i - 1)]) : ""
        currentChar = String(word[word.index(word.startIndex, offsetBy: i)])
        nextChar = i < word.count - 1 ? String(word[word.index(word.startIndex, offsetBy: i + 1)]) : ""
        
        if vowels.contains(currentChar) {
            isVowelFound = true
            if previousChar.isEmpty || nextChar.isEmpty {
                closestVowel = currentChar
                break
            } else if !previousChar.isEmpty && !nextChar.isEmpty {
                closestVowel = currentChar
                break
            }
        }
    }
    
    return isVowelFound ? closestVowel : ""
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var previousChar = ""
    var currentChar = ""
    var nextChar = ""
    var isVowelFound = false
    
    for i in 0..<word.count {
        previousChar = i > 0 ? String(word[word.index(word.startIndex, offsetBy: i - 1)]) : ""
        currentChar = String(word[word.index(word.startIndex, offsetBy: i)])
        nextChar = i < word.count - 1 ? String(word[word.index(word.startIndex, offsetBy: i + 1)]) : ""
        
        if vowels.contains(currentChar) {
            isVowelFound = true
            if previousChar.isEmpty || nextChar.isEmpty {
                closestVowel = currentChar
                break
            } else if !previousChar.isEmpty && !nextChar.isEmpty {
                closestVowel = currentChar
                break
            }
        }
    }
    
    return isVowelFound ? closestVowel : ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var result = ""
    for (index, char) in word.enumerated() {
        if vowels.contains(char) && index < word.count - 1 && index > 0 {
            result = String(char)
            break
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var result = ""
    for (index, char) in word.enumerated() {
        if vowels.contains(char) && index < word.count - 1 && index > 0 {
            result = String(char)
            break
        }
    }
    return result
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    for (index, char) in word.enumerated() {
        if vowels.contains(String(char)) && index != word.count - 1 && index != 0 {
            result = String(char)
            break
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    for (index, char) in word.enumerated() {
        if vowels.contains(String(char)) && index != word.count - 1 && index != 0 {
            result = String(char)
            break
        }
    }
    return result
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    let word = word.lowercased()
    var result = ""
    for i in word.indices.reversed() {
        if vowels.contains(word[i]) {
            result = String(word[i])
            break
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    let word = word.lowercased()
    var result = ""
    for i in word.indices.reversed() {
        if vowels.contains(word[i]) {
            result = String(word[i])
            break
        }
    }
    return result
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var isVowel = false
    for (index, char) in word.enumerated().reversed() {
        if vowels.contains(String(char)) {
            isVowel = true
            result = String(char)
        } else if isVowel && index != word.count - 1 {
            break
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var isVowel = false
    for (index, char) in word.enumerated().reversed() {
        if vowels.contains(String(char)) {
            isVowel = true
            result = String(char)
        } else if isVowel && index != word.count - 1 {
            break
        }
    }
    return result
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    for (index, char) in word.enumerated() {
        if vowels.contains(String(char)) && index > 0 && index < word.count - 1 {
            result = String(char)
            break
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    for (index, char) in word.enumerated() {
        if vowels.contains(String(char)) && index > 0 && index < word.count - 1 {
            result = String(char)
            break
        }
    }
    return result
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    let word = word.lowercased()
    var closestVowel = ""
    for (index, char) in word.enumerated() {
        if vowels.contains(char) && index > 0 && index < word.count - 1 {
            closestVowel = String(char)
            break
        }
    }
    return closestVowel
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    let word = word.lowercased()
    var closestVowel = ""
    for (index, char) in word.enumerated() {
        if vowels.contains(char) && index > 0 && index < word.count - 1 {
            closestVowel = String(char)
            break
        }
    }
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    for (index, char) in word.enumerated() {
        if vowels.contains(String(char)) {
            if index != word.count - 1 {
                if !vowels.contains(String(word[word.index(word.startIndex, offsetBy: index + 1)])) {
                    result = String(char)
                    break
                }
            }
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    for (index, char) in word.enumerated() {
        if vowels.contains(String(char)) {
            if index != word.count - 1 {
                if !vowels.contains(String(word[word.index(word.startIndex, offsetBy: index + 1)])) {
                    result = String(char)
                    break
                }
            }
        }
    }
    return result
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var result = ""
    var isVowel = false
    for (index, char) in word.enumerated() {
        if vowels.contains(char) {
            isVowel = true
        } else if isVowel && index != word.count - 1 {
            result = String(char)
            break
        } else {
            isVowel = false
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var result = ""
    var isVowel = false
    for (index, char) in word.enumerated() {
        if vowels.contains(char) {
            isVowel = true
        } else if isVowel && index != word.count - 1 {
            result = String(char)
            break
        } else {
            isVowel = false
        }
    }
    return result
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    let word = word.lowercased()
    let reversedWord = String(word.reversed())
    for (index, char) in reversedWord.enumerated() {
        if vowels.contains(char) && index != reversedWord.count - 1 && index != 0 {
            return String(char)
        }
    }
    return ""
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    let word = word.lowercased()
    let reversedWord = String(word.reversed())
    for (index, char) in reversedWord.enumerated() {
        if vowels.contains(char) && index != reversedWord.count - 1 && index != 0 {
            return String(char)
        }
    }
    return ""
}
```

func getClosestVowel(word: String) -> String {
    var vowel = ""
    var foundVowel = false
    var foundConsonant = false
    for char in word.reversed() {
        if char == "a" || char == "e" || char == "i" || char == "o" || char == "u" {
            if foundConsonant {
                vowel = String(char)
                foundVowel = true
                break
            }
        } else {
            if foundVowel {
                foundConsonant = true
            }
        }
    }
    return vowel
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""
### Response:
```swift
func getClosestVowel(word: String) -> String {
    var vowel = ""
    var foundVowel = false
    var foundConsonant = false
    for char in word.reversed() {
        if char == "a" || char == "e" || char == "i" || char == "o" || char == "u" {
            if foundConsonant {
                vowel = String(char)
                foundVowel = true
                break
            }
        } else {
            if foundVowel {
                foundConsonant = true
            }
        }
    }
    return vowel
}
```

func getClosestVowel(word: String) -> String {
    // your code here
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    // your code here
}
```

func getClosestVowel(word: String) -> String {
    // your code here
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    // your code here
}
```

func getClosestVowel(word: String) -> String {
    // your code here
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    // your code here
}
```

func getClosestVowel(word: String) -> String {
    // Write your code here
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    // Write your code here
}
```

func getClosestVowel(word: String) -> String {
    // your code here
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    // your code here
}
```

func getClosestVowel(word: String) -> String {
    // your code here
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    // your code here
}
```

func getClosestVowel(word: String) -> String {
    // your code here
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    // your code here
}
```

func getClosestVowel(word: String) -> String {
    // Write your code here
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    // Write your code here
}
```

func getClosestVowel(word: String) -> String {
    // your code here
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    // your code here
}
```

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var closestVowel = ""
    var foundVowel = false
    var foundConsonant = false
    var foundVowelBefore = false
    var foundVowelAfter = false
    var foundConsonantBefore = false
    var foundConsonantAfter = false
    var vowelIndex = -1
    var consonantIndex = -1
    var vowelIndexBefore = -1
    var vowelIndexAfter = -1
    var consonantIndexBefore = -1
    var consonantIndexAfter = -1
    var vowelIndexBefore2 = -1
    var vowelIndexAfter2 = -1
    var consonantIndexBefore2 = -1
    var consonantIndexAfter2 = -1
    var vowelIndexBefore3 = -1
    var vowelIndexAfter3 = -1
    var consonantIndexBefore3 = -1
    var consonantIndexAfter3 = -1
    var vowelIndexBefore4 = -1
    var vowelIndexAfter4 = -1
    var consonantIndexBefore4 = -1
    var consonantIndexAfter4 = -1
    var vowelIndexBefore5 = -1
    var vowelIndexAfter5 = -1
    var consonantIndexBefore5 = -1
    var consonantIndexAfter5 = -1
    var vowelIndexBefore6 = -1
    var vowelIndexAfter6 = -1
    var consonantIndexBefore6 = -1
    var consonantIndexAfter6 = -1
    var vowelIndexBefore7 = -1
    var vowelIndexAfter7 = -1
    var consonantIndexBefore7 = -1
    var consonantIndexAfter7 = -1
    var vowelIndexBefore8 = -1
    var vowelIndexAfter8 = -1
    var consonantIndexBefore8 = -1
    var consonantIndexAfter8 = -1
    var vowelIndexBefore9 = -1
    var vowelIndexAfter9 = -1
    var consonantIndexBefore9 = -1
    var consonantIndexAfter9 = -1
    var vowelIndexBefore10 = -1
    var vowelIndexAfter10 = -1
    var consonantIndexBefore10 = -1
    var consonantIndexAfter10 = -1
    var vowelIndexBefore11 = -1
    var vowelIndexAfter11 = -1
    var consonantIndexBefore11 = -1
    var consonantIndexAfter11 = -1
    var vowelIndexBefore12 = -1
    var vowelIndexAfter12 = -1
    var consonantIndexBefore12 = -1
    var consonantIndexAfter12 = -1
    var vowelIndexBefore13 = -1
    var vowelIndexAfter13 = -1
    var consonantIndexBefore13 = -1
    var consonantIndexAfter13 = -1
    var vowelIndexBefore14 = -1
    var vowelIndexAfter14 = -1
    var consonantIndexBefore14 = -1
    var consonantIndexAfter14 = -1
    var vowelIndexBefore15 = -1
    var vowelIndexAfter15 = -1
    var consonantIndexBefore15 = -1
    var consonantIndexAfter15 = -1
    var vowelIndexBefore16 = -1
    var vowelIndexAfter16 = -1
    var consonantIndexBefore16 = -1
    var consonantIndexAfter16 = -1
    var vowelIndexBefore17 = -1
    var vowelIndexAfter17 = -1
    var consonantIndexBefore17 = -1
    var consonantIndexAfter17 = -1
    var vowelIndexBefore18 = -1
    var vowelIndexAfter18 = -1
    var consonantIndexBefore18 = -1
    var consonantIndexAfter18 = -1
    var vowelIndexBefore19 = -1
    var vowelIndexAfter19 = -1
    var consonantIndexBefore19 = -1
    var consonantIndexAfter19 = -1
    var vowelIndexBefore20 = -1
    var vowelIndexAfter20 = -1
    var consonantIndexBefore20 = -1
    var consonantIndexAfter20 = -1
    var vowelIndexBefore21 = -1

func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var word = word
    while word.count > 0 {
        if vowels.contains(word.last!) {
            return word.last!
        }
        word = word.dropLast()
    }
    return ""
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    var word = word
    while word.count > 0 {
        if vowels.contains(word.last!) {
            return word.last!
        }
        word = word.dropLast()
    }
    return ""
}
<|file_separator|>

func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var word = word.lowercased()
    var index = word.lastIndex(of: word.first!)
    while index != nil {
        if vowels.contains(String(word[index!])) {
            result = String(word[index!])
            break
        }
        index = word.lastIndex(of: word[index! - 1])
    }
    return result
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var word = word.lowercased()
    var index = word.lastIndex(of: word.first!)
    while index != nil {
        if vowels.contains(String(word[index!])) {
            result = String(word[index!])
            break
        }
        index = word.lastIndex(of: word[index! - 1])
    }
    return result
}
<|file_separator|>

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let word = word.lowercased()
    var index = word.index(word.endIndex, offsetBy: -1)
    var closestVowel = ""
    while index != word.startIndex {
        if vowels.contains(String(word[index])) {
            closestVowel = String(word[index])
            break
        }
        index = word.index(before: index)
    }
    return closestVowel
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let word = word.lowercased()
    var index = word.index(word.endIndex, offsetBy: -1)
    var closestVowel = ""
    while index != word.startIndex {
        if vowels.contains(String(word[index])) {
            closestVowel = String(word[index])
            break
        }
        index = word.index(before: index)
    }
    return closestVowel
}
<|file_separator|>

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let wordArray = Array(word)
    var vowel = ""
    var closestVowel = ""
    var closestVowelDistance = 0
    var currentVowelDistance = 0
    for char in wordArray {
        if vowels.contains(String(char)) {
            if closestVowel == "" {
                closestVowel = String(char)
                currentVowelDistance = 0
            } else {
                currentVowelDistance = 0
                for vowel in vowels {
                    if String(char) == vowel {
                        currentVowelDistance = 0
                        break
                    } else {
                        currentVowelDistance += 1
                    }
                }
                if currentVowelDistance < closestVowelDistance {
                    closestVowel = String(char)
                }
            }
        }
    }
    return closestVowel
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let wordArray = Array(word)
    var vowel = ""
    var closestVowel = ""
    var closestVowelDistance = 0
    var currentVowelDistance = 0
    for char in wordArray {
        if vowels.contains(String(char)) {
            if closestVowel == "" {
                closestVowel = String(char)
                currentVowelDistance = 0
            } else {
                currentVowelDistance = 0
                for vowel in vowels {
                    if String(char) == vowel {
                        currentVowelDistance = 0
                        break
                    } else {
                        currentVowelDistance += 1
                    }
                }
                if currentVowelDistance < closestVowelDistance {
                    closestVowel = String(char)
                }
            }
        }
    }
    return closestVowel
}
<|file_separator|>

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var wordArray = Array(word)
    var wordLength = wordArray.count
    var vowelIndex = -1
    var vowelFound = false
    var vowelFoundIndex = -1
    var vowelFoundIndex2 = -1
    var vowelFoundIndex3 = -1
    var vowelFoundIndex4 = -1
    var vowelFoundIndex5 = -1
    var vowelFoundIndex6 = -1
    var vowelFoundIndex7 = -1
    var vowelFoundIndex8 = -1
    var vowelFoundIndex9 = -1
    var vowelFoundIndex10 = -1
    var vowelFoundIndex11 = -1
    var vowelFoundIndex12 = -1
    var vowelFoundIndex13 = -1
    var vowelFoundIndex14 = -1
    var vowelFoundIndex15 = -1
    var vowelFoundIndex16 = -1
    var vowelFoundIndex17 = -1
    var vowelFoundIndex18 = -1
    var vowelFoundIndex19 = -1
    var vowelFoundIndex20 = -1
    var vowelFoundIndex21 = -1
    var vowelFoundIndex22 = -1
    var vowelFoundIndex23 = -1
    var vowelFoundIndex24 = -1
    var vowelFoundIndex25 = -1
    var vowelFoundIndex26 = -1
    var vowelFoundIndex27 = -1
    var vowelFoundIndex28 = -1
    var vowelFoundIndex29 = -1
    var vowelFoundIndex30 = -1
    var vowelFoundIndex31 = -1
    var vowelFoundIndex32 = -1
    var vowelFoundIndex33 = -1
    var vowelFoundIndex34 = -1
    var vowelFoundIndex35 = -1
    var vowelFoundIndex36 = -1
    var vowelFoundIndex37 = -1
    var vowelFoundIndex38 = -1
    var vowelFoundIndex39 = -1
    var vowelFoundIndex40 = -1
    var vowelFoundIndex41 = -1
    var vowelFoundIndex42 = -1
    var vowelFoundIndex43 = -1
    var vowelFoundIndex44 = -1
    var vowelFoundIndex45 = -1
    var vowelFoundIndex46 = -1
    var vowelFoundIndex47 = -1
    var vowelFoundIndex48 = -1
    var vowelFoundIndex49 = -1
    var vowelFoundIndex50 = -1
    var vowelFoundIndex51 = -1
    var vowelFoundIndex52 = -1
    var vowelFoundIndex53 = -1
    var vowelFoundIndex54 = -1
    var vowelFoundIndex55 = -1
    var vowelFoundIndex56 = -1
    var vowelFoundIndex57 = -1
    var vowelFoundIndex58 = -1
    var vowelFoundIndex59 = -1
    var vowelFoundIndex60 = -1
    var vowelFoundIndex61 = -1
    var vowelFoundIndex62 = -1
    var vowelFoundIndex63 = -1
    var vowelFoundIndex64 = -1
    var vowelFoundIndex65 = -1
    var vowelFoundIndex66 = -1
    var vowelFoundIndex67 = -1
    var vowelFoundIndex68 = -1
    var vowelFoundIndex69 = -1
    var vowelFoundIndex70 = -1
    var vowelFoundIndex71 = -1
    var vowelFoundIndex72 = -1
    var vowelFoundIndex73 = -1
    var vowelFoundIndex74 = -1
    var vowelFoundIndex75 = -1
    var vowelFoundIndex76 = -1
    var vowelFoundIndex77 = -1
    var vowelFoundIndex78 = -1
    var vowelFoundIndex79 = -1
    var vowelFoundIndex80 = -1
    var vowelFoundIndex81 = -1
    var vowelFoundIndex82 = -1
    var vowelFoundIndex83 = -1
    var vowelFoundIndex84 = -1
    var vowelFoundIndex85 = -1
    var vowelFoundIndex86 = -1
    var vowelFoundIndex87 = -1
    var vowelFoundIndex88 = -1
    var vowelFound

func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    for i in 0..<word.count {
        if vowels.contains(String(word[word.index(word.startIndex, offsetBy: i)])) {
            result = String(word[word.index(word.startIndex, offsetBy: i)])
            break
        }
    }
    for i in (0..<word.count).reversed() {
        if vowels.contains(String(word[word.index(word.startIndex, offsetBy: i)])) {
            result = String(word[word.index(word.startIndex, offsetBy: i)])
            break
        }
    }
    return result
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    for i in 0..<word.count {
        if vowels.contains(String(word[word.index(word.startIndex, offsetBy: i)])) {
            result = String(word[word.index(word.startIndex, offsetBy: i)])
            break
        }
    }
    for i in (0..<word.count).reversed() {
        if vowels.contains(String(word[word.index(word.startIndex, offsetBy: i)])) {
            result = String(word[word.index(word.startIndex, offsetBy: i)])
            break
        }
    }
    return result
}
<|file_separator|>

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let word = word.lowercased()
    let wordArray = Array(word)
    var vowel = ""
    for i in 0..<wordArray.count {
        if vowels.contains(String(wordArray[wordArray.count - i - 1])) {
            vowel = String(wordArray[wordArray.count - i - 1])
            break
        }
    }
    if vowel == "" {
        return ""
    }
    var closestVowel = ""
    for i in 0..<wordArray.count {
        if vowels.contains(String(wordArray[i])) {
            closestVowel = String(wordArray[i])
            break
        }
    }
    if closestVowel == "" {
        return ""
    }
    for i in 0..<wordArray.count {
        if String(wordArray[wordArray.count - i - 1]) == closestVowel {
            return closestVowel
        }
    }
    return ""
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let word = word.lowercased()
    let wordArray = Array(word)
    var vowel = ""
    for i in 0..<wordArray.count {
        if vowels.contains(String(wordArray[wordArray.count - i - 1])) {
            vowel = String(wordArray[wordArray.count - i - 1])
            break
        }
    }
    if vowel == "" {
        return ""
    }
    var closestVowel = ""
    for i in 0..<wordArray.count {
        if vowels.contains(String(wordArray[i])) {
            closestVowel = String(wordArray[i])
            break
        }
    }
    if closestVowel == "" {
        return ""
    }
    for i in 0..<wordArray.count {
        if String(wordArray[wordArray.count - i - 1]) == closestVowel {
            return closestVowel
        }
    }
    return ""
}
<|file_separator|>

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let wordArray = Array(word)
    var result = ""
    var index = 0
    for char in wordArray {
        if vowels.contains(String(char)) {
            result = String(char)
            break
        } else {
            index += 1
        }
    }
    if result == "" {
        return ""
    }
    let wordLength = wordArray.count
    let leftIndex = wordLength - index
    let rightIndex = wordLength - index - 1
    if leftIndex > rightIndex {
        for char in wordArray.reversed() {
            if vowels.contains(String(char)) {
                result = String(char)
                break
            } else {
                index += 1
            }
        }
    }
    return result
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let wordArray = Array(word)
    var result = ""
    var index = 0
    for char in wordArray {
        if vowels.contains(String(char)) {
            result = String(char)
            break
        } else {
            index += 1
        }
    }
    if result == "" {
        return ""
    }
    let wordLength = wordArray.count
    let leftIndex = wordLength - index
    let rightIndex = wordLength - index - 1
    if leftIndex > rightIndex {
        for char in wordArray.reversed() {
            if vowels.contains(String(char)) {
                result = String(char)
                break
            } else {
                index += 1
            }
        }
    }
    return result
}
<|file_separator|>

func getClosestVowel(word: String) -> String {
    var vowel = ""
    for i in word.indices {
        if word[i] == "a" || word[i] == "e" || word[i] == "i" || word[i] == "o" || word[i] == "u" {
            vowel = String(word[i])
            break
        }
    }
    if vowel == "" {
        return ""
    }
    var closestVowel = ""
    for i in word.indices {
        if word[word.index(before: i)] == "a" || word[word.index(before: i)] == "e" || word[word.index(before: i)] == "i" || word[word.index(before: i)] == "o" || word[word.index(before: i)] == "u" {
            closestVowel = String(word[word.index(before: i)])
            break
        }
    }
    if closestVowel == "" {
        return ""
    }
    if vowel == "a" || vowel == "e" || vowel == "i" || vowel == "o" || vowel == "u" {
        return closestVowel
    }
    if vowel == "A" || vowel == "E" || vowel == "I" || vowel == "O" || vowel == "U" {
        return closestVowel
    }
    if vowel == "b" || vowel == "c" || vowel == "d" || vowel == "f" || vowel == "g" || vowel == "h" || vowel == "j" || vowel == "k" || vowel == "l" || vowel == "m" || vowel == "n" || vowel == "p" || vowel == "q" || vowel == "r" || vowel == "s" || vowel == "t" || vowel == "v" || vowel == "w" || vowel == "x" || vowel == "y" || vowel == "z" {
        return closestVowel
    }
    if vowel == "B" || vowel == "C" || vowel == "D" || vowel == "F" || vowel == "G" || vowel == "H" || vowel == "J" || vowel == "K" || vowel == "L" || vowel == "M" || vowel == "N" || vowel == "P" || vowel == "Q" || vowel == "R" || vowel == "S" || vowel == "T" || vowel == "V" || vowel == "W" || vowel == "X" || vowel == "Y" || vowel == "Z" {
        return closestVowel
    }
    return ""
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowel = ""
    for i in word.indices {
        if word[i] == "a" || word[i] == "e" || word[i] == "i" || word[i] == "o" || word[i] == "u" {
            vowel = String(word[i])
            break
        }
    }
    if vowel == "" {
        return ""
    }
    var closestVowel = ""
    for i in word.indices {
        if word[word.index(before: i)] == "a" || word[word.index(before: i)] == "e" || word[word.index(before: i)] == "i" || word[word.index(before: i)] == "o" || word[word.index(before: i)] == "u" {
            closestVowel = String(word[word.index(before: i)])
            break
        }
    }
    if closestVowel == "" {
        return ""
    }
    if vowel == "a" || vowel == "e" || vowel == "i" || vowel == "o" || vowel == "u" {
        return closestVowel
    }
    if vowel == "A" || vowel == "E" || vowel == "I" || vowel == "O" || vowel == "U" {
        return closestVowel
    }
    if vowel == "b" || vowel == "c" || vowel == "d" || vowel == "f" || vowel == "g" || vowel == "h" || vowel == "j" || vowel == "k" || vowel == "l" || vowel == "m" || vowel == "n" || vowel == "p" || vowel == "q" || vowel == "r" || vowel == "s" || vowel == "t" || vowel == "v" || vowel == "w" || vowel == "x" || vowel == "y" || vowel == "z" {
        return closestVowel
    }
    if vowel == "B" || vowel == "C" || vowel == "D" || vowel == "F" || vowel == "G" || vowel == "H" || vowel == "J" || vowel == "K" || vowel == "L" || vowel == "M" || vowel == "N" || vowel == "P" || vowel == "Q" || vowel == "R" || vowel == "S" || vowel == "T" || vowel == "V" || vowel == "W" || vowel == "X" || vowel == "Y" || vowel == "Z" {
        return closestVowel
    }
    return ""
}
<|file_separator|>```

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var word = word
    var index = 0
    var result = ""
    var count = 0
    var count2 = 0
    var count3 = 0
    var count4 = 0
    var count5 = 0
    var count6 = 0
    var count7 = 0
    var count8 = 0
    var count9 = 0
    var count10 = 0
    var count11 = 0
    var count12 = 0
    var count13 = 0
    var count14 = 0
    var count15 = 0
    var count16 = 0
    var count17 = 0
    var count18 = 0
    var count19 = 0
    var count20 = 0
    var count21 = 0
    var count22 = 0
    var count23 = 0
    var count24 = 0
    var count25 = 0
    var count26 = 0
    var count27 = 0
    var count28 = 0
    var count29 = 0
    var count30 = 0
    var count31 = 0
    var count32 = 0
    var count33 = 0
    var count34 = 0
    var count35 = 0
    var count36 = 0
    var count37 = 0
    var count38 = 0
    var count39 = 0
    var count40 = 0
    var count41 = 0
    var count42 = 0
    var count43 = 0
    var count44 = 0
    var count45 = 0
    var count46 = 0
    var count47 = 0
    var count48 = 0
    var count49 = 0
    var count50 = 0
    var count51 = 0
    var count52 = 0
    var count53 = 0
    var count54 = 0
    var count55 = 0
    var count56 = 0
    var count57 = 0
    var count58 = 0
    var count59 = 0
    var count60 = 0
    var count61 = 0
    var count62 = 0
    var count63 = 0
    var count64 = 0
    var count65 = 0
    var count66 = 0
    var count67 = 0
    var count68 = 0
    var count69 = 0
    var count70 = 0
    var count71 = 0
    var count72 = 0
    var count73 = 0
    var count74 = 0
    var count75 = 0
    var count76 = 0
    var count77 = 0
    var count78 = 0
    var count79 = 0
    var count80 = 0
    var count81 = 0
    var count82 = 0
    var count83 = 0
    var count84 = 0
    var count85 = 0
    var count86 = 0
    var count87 = 0
    var count88 = 0
    var count89 = 0
    var count90 = 0
    var count91 = 0
    var count92 = 0
    var count93 = 0
    var count94 = 0
    var count95 = 0
    var count96 = 0
    var count97 = 0
    var count98 = 0
    var count99 = 0
    var count100 = 0
    var count101 = 0
    var count102 = 0
    var count103 = 0
    var count104 = 0
    var count105 = 0
    var count106 = 0
    var count107 = 0
    var count108 = 0
    var count109 = 0
    var count

func getClosestVowel(word: String) -> String {
    var vowel = ""
    for char in word {
        if char == "a" || char == "e" || char == "i" || char == "o" || char == "u" {
            vowel = String(char)
            break
        }
    }
    if vowel == "" {
        return ""
    }
    var index = 0
    for char in word {
        if char == "a" || char == "e" || char == "i" || char == "o" || char == "u" {
            index = word.index(word.startIndex, offsetBy: index)
            break
        }
        index += 1
    }
    var result = ""
    for char in word {
        if char == "a" || char == "e" || char == "i" || char == "o" || char == "u" {
            result = String(char)
            break
        }
        if word.index(word.startIndex, offsetBy: index) == word.endIndex {
            break
        }
        index += 1
    }
    return result
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowel = ""
    for char in word {
        if char == "a" || char == "e" || char == "i" || char == "o" || char == "u" {
            vowel = String(char)
            break
        }
    }
    if vowel == "" {
        return ""
    }
    var index = 0
    for char in word {
        if char == "a" || char == "e" || char == "i" || char == "o" || char == "u" {
            index = word.index(word.startIndex, offsetBy: index)
            break
        }
        index += 1
    }
    var result = ""
    for char in word {
        if char == "a" || char == "e" || char == "i" || char == "o" || char == "u" {
            result = String(char)
            break
        }
        if word.index(word.startIndex, offsetBy: index) == word.endIndex {
            break
        }
        index += 1
    }
    return result
}
<|file_separator|>

func getClosestVowel(word: String) -> String {
    var vowel = ""
    var vowelIndex = 0
    var vowelFound = false
    var vowelFoundIndex = 0
    for (index, char) in word.enumerated() {
        if char == "a" || char == "e" || char == "i" || char == "o" || char == "u" {
            vowel = char
            vowelIndex = index
            vowelFound = true
        }
    }
    if vowelFound {
        for (index, char) in word.reversed().enumerated() {
            if char == "a" || char == "e" || char == "i" || char == "o" || char == "u" {
                vowelFoundIndex = index
                break
            }
        }
        if vowelFoundIndex > vowelIndex {
            return vowel
        }
    }
    return ""
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowel = ""
    var vowelIndex = 0
    var vowelFound = false
    var vowelFoundIndex = 0
    for (index, char) in word.enumerated() {
        if char == "a" || char == "e" || char == "i" || char == "o" || char == "u" {
            vowel = char
            vowelIndex = index
            vowelFound = true
        }
    }
    if vowelFound {
        for (index, char) in word.reversed().enumerated() {
            if char == "a" || char == "e" || char == "i" || char == "o" || char == "u" {
                vowelFoundIndex = index
                break
            }
        }
        if vowelFoundIndex > vowelIndex {
            return vowel
        }
    }
    return ""
}
<|file_separator|>

func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var word = word.lowercased()
    var result = ""
    var index = word.index(word.endIndex, offsetBy: -1)
    while index != word.startIndex {
        if vowels.contains(String(word[index])) {
            result = String(word[index])
            break
        }
        index = word.index(before: index)
    }
    return result
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var word = word.lowercased()
    var result = ""
    var index = word.index(word.endIndex, offsetBy: -1)
    while index != word.startIndex {
        if vowels.contains(String(word[index])) {
            result = String(word[index])
            break
        }
        index = word.index(before: index)
    }
    return result
}<|file_separator|>```

func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var word = word.lowercased()
    var result = ""
    var i = word.count - 1
    while i >= 0 {
        if vowels.contains(String(word[word.index(word.startIndex, offsetBy: i)])) {
            result = String(word[word.index(word.startIndex, offsetBy: i)])
            break
        }
        i -= 1
    }
    return result
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var word = word.lowercased()
    var result = ""
    var i = word.count - 1
    while i >= 0 {
        if vowels.contains(String(word[word.index(word.startIndex, offsetBy: i)])) {
            result = String(word[word.index(word.startIndex, offsetBy: i)])
            break
        }
        i -= 1
    }
    return result
}
<|file_separator|>

func getClosestVowel(word: String) -> String {
    var vowel = ""
    let vowels = ["a", "e", "i", "o", "u"]
    let word = word.lowercased()
    let wordArray = Array(word)
    for i in 0..<wordArray.count {
        if vowels.contains(String(wordArray[wordArray.count - 1 - i])) {
            vowel = String(wordArray[wordArray.count - 1 - i])
            break
        }
    }
    if vowel == "" {
        return ""
    }
    for i in 0..<wordArray.count {
        if vowels.contains(String(wordArray[i])) {
            if wordArray[i] == "u" {
                return ""
            }
            return String(wordArray[i])
        }
    }
    return ""
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowel = ""
    let vowels = ["a", "e", "i", "o", "u"]
    let word = word.lowercased()
    let wordArray = Array(word)
    for i in 0..<wordArray.count {
        if vowels.contains(String(wordArray[wordArray.count - 1 - i])) {
            vowel = String(wordArray[wordArray.count - 1 - i])
            break
        }
    }
    if vowel == "" {
        return ""
    }
    for i in 0..<wordArray.count {
        if vowels.contains(String(wordArray[i])) {
            if wordArray[i] == "u" {
                return ""
            }
            return String(wordArray[i])
        }
    }
    return ""
}
<|file_separator|>

func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var word = word
    var result = ""
    var vowel = ""
    var i = 0
    while i < word.count {
        if vowels.contains(String(word[word.index(word.startIndex, offsetBy: i)])) {
            vowel = String(word[word.index(word.startIndex, offsetBy: i)])
            break
        }
        i += 1
    }
    if vowel == "" {
        return ""
    }
    var j = word.count - 1
    while j >= 0 {
        if vowels.contains(String(word[word.index(word.startIndex, offsetBy: j)])) {
            if j == word.count - 1 {
                return ""
            }
            result = String(word[word.index(word.startIndex, offsetBy: j + 1)])
            break
        }
        j -= 1
    }
    if result == "" {
        return ""
    }
    if vowel == "a" || vowel == "e" || vowel == "i" || vowel == "o" || vowel == "u" {
        return ""
    }
    return result
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var word = word
    var result = ""
    var vowel = ""
    var i = 0
    while i < word.count {
        if vowels.contains(String(word[word.index(word.startIndex, offsetBy: i)])) {
            vowel = String(word[word.index(word.startIndex, offsetBy: i)])
            break
        }
        i += 1
    }
    if vowel == "" {
        return ""
    }
    var j = word.count - 1
    while j >= 0 {
        if vowels.contains(String(word[word.index(word.startIndex, offsetBy: j)])) {
            if j == word.count - 1 {
                return ""
            }
            result = String(word[word.index(word.startIndex, offsetBy: j + 1)])
            break
        }
        j -= 1
    }
    if result == "" {
        return ""
    }
    if vowel == "a" || vowel == "e" || vowel == "i" || vowel == "o" || vowel == "u" {
        return ""
    }
    return result
}
<|file_separator|>

func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    let wordArray = Array(word)
    var vowelFound = false
    var closestVowel = ""
    for i in 0..<wordArray.count {
        if vowels.contains(String(wordArray[wordArray.count - i - 1])) {
            vowelFound = true
            closestVowel = String(wordArray[wordArray.count - i - 1])
            break
        }
    }
    if !vowelFound {
        return ""
    }
    for i in 0..<wordArray.count {
        if vowels.contains(String(wordArray[i])) {
            return closestVowel
        }
    }
    return ""
}

func longestPalindrome(words: String) -> String {
    var longestPalindrome = ""
    let wordsArray = Array(words)
    for i in 0..<wordsArray.count {
        for j in i+1..<wordsArray.count {
            if isPalindrome(word: String(wordsArray[i...j])) && String(wordsArray[i...j]) > longestPalindrome {
                longestPalindrome = String(wordsArray[i...j])
            }
        }
    }
    return longestPalindrome
}

func isPalindrome(word: String) -> Bool {
    let wordArray = Array(word)
    for i in 0..<wordArray.count/2 {
        if wordArray[i] != wordArray[wordArray.count - i - 1] {
            return false
        }
    }
    return true
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    let wordArray = Array(word)
    var vowelFound = false
    var closestVowel = ""
    for i in 0..<wordArray.count {
        if vowels.contains(String(wordArray[wordArray.count - i - 1])) {
            vowelFound = true
            closestVowel = String(wordArray[wordArray.count - i - 1])
            break
        }
    }
    if !vowelFound {
        return ""
    }
    for i in 0..<wordArray.count {
        if vowels.contains(String(wordArray[i])) {
            return closestVowel
        }
    }
    return ""
}

// You are given a string of words. Your task is to find the longest word that is a 
// palindrome. If there are more than one longest palindrome, return the first one.
// Example:
// longestPalindrome(words: "a b c b a") == "b c b a"
// longestPalindrome(words: "a b c b a b") == "b c b a"
// longestPalindrome(words: "a b c b a b c") == "b c b a"
// longestPalindrome(words: "a b c b a b c d") == "b c b a"
// longestPalindrome(words: "a b c b a b c d e") == "b c b a"
func longestPalindrome(words: String) -> String {
    var longestPalindrome = ""
    let wordsArray = Array(words)
    for i in 0..<wordsArray.count {
        for j in i+1..<wordsArray.count {
            if isPalindrome(word: String(wordsArray[i...j])) && String(wordsArray[i...j]) > longestPalindrome {
                longestPalindrome = String(wordsArray[i...j])
            }
        }
    }
    return longestPalindrome
}

func isPalindrome(word: String) -> Bool {
    let wordArray = Array(word)
    for i in 0..<wordArray.count/2 {
        if wordArray[i] != wordArray[wordArray.count - i - 1] {
            return false
        }
    }
    return true
}

// You are given a string of words. Your task is to find the longest word that is a 
// palindrome. If there are more than one longest palindrome, return the first one.
// Example:
// longestPalindrome(words: "a b c b a") == "b c b a"
// longestPalindrome(words: "a b c b a b") == "b c b a"
// longestPalindrome(words: "a b c b a b c") == "b c b a"
// longestPalindrome(words: "a b c b a b c d") == "b c b a"
// longestPalindrome(words: "a b c b a b c d e") == "b c b a"
func longestPalindrome(words: String) -> String {
    var longestPalindrome = ""
    let wordsArray = Array(words)
    for i in 0..<wordsArray.count {
        for j in i+1..<wordsArray.count {
            if isPalindrome(word: String(wordsArray[i...j])) && String(wordsArray[i...j]) > longestPalindrome {
                longestPalindrome = String(wordsArray[i...j])
            }
        }
    }
    return longestPalindrome
}

func isPalindrome(word: String) -> Bool {
    let wordArray = Array(word)
    for i in 0..<wordArray.count/2 {
        if wordArray[i] != wordArray[wordArray.count - i - 1] {
            return false
        }
    }
    return true
}

// You are given a string of words. Your task is to find the longest word that is a 
// palindrome. If there are more than one longest palindrome, return the first one.
// Example:
// longestPalindrome(words: "a b c b a") == "b c b a"
// longestPalindrome(words: "a b c b a b") == "b c b a"
// longestPalindrome(words: "a b c b a b c") == "b c b a"
// longestPalindrome(words: "a b c b a b c d") == "b c b a"
// longestPalindrome(words: "a

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let wordArray = Array(word)
    var vowel = ""
    for i in 0..<wordArray.count {
        if vowels.contains(String(wordArray[wordArray.count - i - 1])) {
            vowel = String(wordArray[wordArray.count - i - 1])
            break
        }
    }
    if vowel == "" {
        return ""
    }
    for i in 0..<wordArray.count {
        if vowels.contains(String(wordArray[i])) {
            return vowel
        }
    }
    return ""
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let wordArray = Array(word)
    var vowel = ""
    for i in 0..<wordArray.count {
        if vowels.contains(String(wordArray[wordArray.count - i - 1])) {
            vowel = String(wordArray[wordArray.count - i - 1])
            break
        }
    }
    if vowel == "" {
        return ""
    }
    for i in 0..<wordArray.count {
        if vowels.contains(String(wordArray[i])) {
            return vowel
        }
    }
    return ""
}
<|file_separator|>

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var wordArray = Array(word)
    var vowelIndex = 0
    var vowelFound = false
    var vowelFoundIndex = 0
    var vowelFoundIndex2 = 0
    var vowelFoundIndex3 = 0
    var vowelFoundIndex4 = 0
    var vowelFoundIndex5 = 0
    var vowelFoundIndex6 = 0
    var vowelFoundIndex7 = 0
    var vowelFoundIndex8 = 0
    var vowelFoundIndex9 = 0
    var vowelFoundIndex10 = 0
    var vowelFoundIndex11 = 0
    var vowelFoundIndex12 = 0
    var vowelFoundIndex13 = 0
    var vowelFoundIndex14 = 0
    var vowelFoundIndex15 = 0
    var vowelFoundIndex16 = 0
    var vowelFoundIndex17 = 0
    var vowelFoundIndex18 = 0
    var vowelFoundIndex19 = 0
    var vowelFoundIndex20 = 0
    var vowelFoundIndex21 = 0
    var vowelFoundIndex22 = 0
    var vowelFoundIndex23 = 0
    var vowelFoundIndex24 = 0
    var vowelFoundIndex25 = 0
    var vowelFoundIndex26 = 0
    var vowelFoundIndex27 = 0
    var vowelFoundIndex28 = 0
    var vowelFoundIndex29 = 0
    var vowelFoundIndex30 = 0
    var vowelFoundIndex31 = 0
    var vowelFoundIndex32 = 0
    var vowelFoundIndex33 = 0
    var vowelFoundIndex34 = 0
    var vowelFoundIndex35 = 0
    var vowelFoundIndex36 = 0
    var vowelFoundIndex37 = 0
    var vowelFoundIndex38 = 0
    var vowelFoundIndex39 = 0
    var vowelFoundIndex40 = 0
    var vowelFoundIndex41 = 0
    var vowelFoundIndex42 = 0
    var vowelFoundIndex43 = 0
    var vowelFoundIndex44 = 0
    var vowelFoundIndex45 = 0
    var vowelFoundIndex46 = 0
    var vowelFoundIndex47 = 0
    var vowelFoundIndex48 = 0
    var vowelFoundIndex49 = 0
    var vowelFoundIndex50 = 0
    var vowelFoundIndex51 = 0
    var vowelFoundIndex52 = 0
    var vowelFoundIndex53 = 0
    var vowelFoundIndex54 = 0
    var vowelFoundIndex55 = 0
    var vowelFoundIndex56 = 0
    var vowelFoundIndex57 = 0
    var vowelFoundIndex58 = 0
    var vowelFoundIndex59 = 0
    var vowelFoundIndex60 = 0
    var vowelFoundIndex61 = 0
    var vowelFoundIndex62 = 0
    var vowelFoundIndex63 = 0
    var vowelFoundIndex64 = 0
    var vowelFoundIndex65 = 0
    var vowelFoundIndex66 = 0
    var vowelFoundIndex67 = 0
    var vowelFoundIndex68 = 0
    var vowelFoundIndex69 = 0
    var vowelFoundIndex70 = 0
    var vowelFoundIndex71 = 0
    var vowelFoundIndex72 = 0
    var vowelFoundIndex73 = 0
    var vowelFoundIndex74 = 0
    var vowelFoundIndex75 = 0
    var vowelFoundIndex76 = 0
    var vowelFoundIndex77 = 0
    var vowelFoundIndex78 = 0
    var vowelFoundIndex79 = 0
    var vowelFoundIndex80 = 0
    var vowelFoundIndex81 = 0
    var vowelFoundIndex82 = 0
    var vowelFoundIndex83 = 0
    var vowelFoundIndex84 = 0
    var vowelFoundIndex85 = 0
    var vowelFoundIndex86 = 0
    var vowelFoundIndex87 = 0
    var vowelFoundIndex88 = 0
    var vowelFoundIndex89 = 0
    var vowel

func getClosestVowel(word: String) -> String {
    var vowel = ""
    var vowelIndex = -1
    for i in 0..<word.count {
        if word[word.index(word.startIndex, offsetBy: i)] == "a" ||
            word[word.index(word.startIndex, offsetBy: i)] == "e" ||
            word[word.index(word.startIndex, offsetBy: i)] == "i" ||
            word[word.index(word.startIndex, offsetBy: i)] == "o" ||
            word[word.index(word.startIndex, offsetBy: i)] == "u" {
            vowel = String(word[word.index(word.startIndex, offsetBy: i)])
            vowelIndex = i
            break
        }
    }
    if vowelIndex == -1 {
        return ""
    }
    var closestVowel = ""
    var closestVowelIndex = -1
    for i in vowelIndex+1..<word.count {
        if word[word.index(word.startIndex, offsetBy: i)] == "a" ||
            word[word.index(word.startIndex, offsetBy: i)] == "e" ||
            word[word.index(word.startIndex, offsetBy: i)] == "i" ||
            word[word.index(word.startIndex, offsetBy: i)] == "o" ||
            word[word.index(word.startIndex, offsetBy: i)] == "u" {
            closestVowel = String(word[word.index(word.startIndex, offsetBy: i)])
            closestVowelIndex = i
            break
        }
    }
    if closestVowelIndex == -1 {
        return ""
    }
    return closestVowel
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowel = ""
    var vowelIndex = -1
    for i in 0..<word.count {
        if word[word.index(word.startIndex, offsetBy: i)] == "a" ||
            word[word.index(word.startIndex, offsetBy: i)] == "e" ||
            word[word.index(word.startIndex, offsetBy: i)] == "i" ||
            word[word.index(word.startIndex, offsetBy: i)] == "o" ||
            word[word.index(word.startIndex, offsetBy: i)] == "u" {
            vowel = String(word[word.index(word.startIndex, offsetBy: i)])
            vowelIndex = i
            break
        }
    }
    if vowelIndex == -1 {
        return ""
    }
    var closestVowel = ""
    var closestVowelIndex = -1
    for i in vowelIndex+1..<word.count {
        if word[word.index(word.startIndex, offsetBy: i)] == "a" ||
            word[word.index(word.startIndex, offsetBy: i)] == "e" ||
            word[word.index(word.startIndex, offsetBy: i)] == "i" ||
            word[word.index(word.startIndex, offsetBy: i)] == "o" ||
            word[word.index(word.startIndex, offsetBy: i)] == "u" {
            closestVowel = String(word[word.index(word.startIndex, offsetBy: i)])
            closestVowelIndex = i
            break
        }
    }
    if closestVowelIndex == -1 {
        return ""
    }
    return closestVowel
}
<|file_separator|>

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var consonants = [Character]()
    var vowelsIndex = [Int]()
    
    for (index, char) in word.characters.enumerate() {
        if vowels.contains(char.lowercaseString) {
            vowelsIndex.append(index)
        } else {
            consonants.append(char)
        }
    }
    
    if vowelsIndex.count == 0 {
        return ""
    }
    
    let lastVowelsIndex = vowelsIndex.last!
    let lastVowel = word[word.startIndex.advancedBy(lastVowelsIndex)]
    
    if lastVowelsIndex == word.characters.count - 1 {
        return ""
    }
    
    let consonantsBetweenVowels = consonants.reverse().enumerate().filter({
        $0.index < lastVowelsIndex
    })
    
    let consonantsBetweenVowelsCount = consonantsBetweenVowels.count
    if consonantsBetweenVowelsCount == 0 {
        return ""
    }
    
    let lastConsonantIndex = consonantsBetweenVowels[consonantsBetweenVowelsCount - 1].index
    let lastConsonant = consonants[lastConsonantIndex]
    
    if consonantsBetweenVowelsCount == 1 {
        return String(lastConsonant)
    }
    
    let firstConsonantIndex = consonantsBetweenVowels[0].index
    let firstConsonant = consonants[firstConsonantIndex]
    
    if lastVowelsIndex - lastConsonantIndex < firstConsonantIndex - lastVowelsIndex {
        return String(lastConsonant)
    } else {
        return String(firstConsonant)
    }
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var consonants = [Character]()
    var vowelsIndex = [Int]()
    
    for (index, char) in word.characters.enumerate() {
        if vowels.contains(char.lowercaseString) {
            vowelsIndex.append(index)
        } else {
            consonants.append(char)
        }
    }
    
    if vowelsIndex.count == 0 {
        return ""
    }
    
    let lastVowelsIndex = vowelsIndex.last!
    let lastVowel = word[word.startIndex.advancedBy(lastVowelsIndex)]
    
    if lastVowelsIndex == word.characters.count - 1 {
        return ""
    }
    
    let consonantsBetweenVowels = consonants.reverse().enumerate().filter({
        $0.index < lastVowelsIndex
    })
    
    let consonantsBetweenVowelsCount = consonantsBetweenVowels.count
    if consonantsBetweenVowelsCount == 0 {
        return ""
    }
    
    let lastConsonantIndex = consonantsBetweenVowels[consonantsBetweenVowelsCount - 1].index
    let lastConsonant = consonants[lastConsonantIndex]
    
    if consonantsBetweenVowelsCount == 1 {
        return String(lastConsonant)
    }
    
    let firstConsonantIndex = consonantsBetweenVowels[0].index
    let firstConsonant = consonants[firstConsonantIndex]
    
    if lastVowelsIndex - lastConsonantIndex < firstConsonantIndex - lastVowelsIndex {
        return String(lastConsonant)
    } else {
        return String(firstConsonant)
    }
}
```

func getClosestVowel(word: String) -> String {
  let vowels: [Character] = ["a", "e", "i", "o", "u"]
  var consonants: [Character] = []
  var vowelsFound: [Character] = []
  var closestVowel: Character?
  let wordArray: [Character] = Array(word)
  for i in 0..<word.count {
    if vowels.contains(wordArray[i]) {
      vowelsFound.append(wordArray[i])
    } else {
      consonants.append(wordArray[i])
    }
  }
  if consonants.count > vowelsFound.count {
    for i in 0..<consonants.count-1 {
      if consonants[i] != consonants[i+1] {
        for j in 0..<vowelsFound.count {
          if consonants[i+1] == vowelsFound[j] {
            closestVowel = vowelsFound[j]
          }
        }
      }
    }
  }
  return String(closestVowel ?? "")
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
  let vowels: [Character] = ["a", "e", "i", "o", "u"]
  var consonants: [Character] = []
  var vowelsFound: [Character] = []
  var closestVowel: Character?
  let wordArray: [Character] = Array(word)
  for i in 0..<word.count {
    if vowels.contains(wordArray[i]) {
      vowelsFound.append(wordArray[i])
    } else {
      consonants.append(wordArray[i])
    }
  }
  if consonants.count > vowelsFound.count {
    for i in 0..<consonants.count-1 {
      if consonants[i] != consonants[i+1] {
        for j in 0..<vowelsFound.count {
          if consonants[i+1] == vowelsFound[j] {
            closestVowel = vowelsFound[j]
          }
        }
      }
    }
  }
  return String(closestVowel ?? "")
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    
    var consonants = [Character]()
    for char in word {
        if !vowels.contains(String(char)) {
            consonants.append(char)
        }
    }
    
    var closestVowel = ""
    if consonants.count >= 2 {
        for i in stride(from: consonants.count - 1, to: 0, by: -1) {
            if vowels.contains(String(consonants[i])) {
                closestVowel = String(consonants[i])
                break
            }
        }
    }
    return closestVowel
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    
    var consonants = [Character]()
    for char in word {
        if !vowels.contains(String(char)) {
            consonants.append(char)
        }
    }
    
    var closestVowel = ""
    if consonants.count >= 2 {
        for i in stride(from: consonants.count - 1, to: 0, by: -1) {
            if vowels.contains(String(consonants[i])) {
                closestVowel = String(consonants[i])
                break
            }
        }
    }
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    // your code here
    let vowels = "aeiouy"
    let consonants = "bcdfghjklmnpqrstvwxyz"
    var closestVowel = ""
    
    for i in (0...word.count - 1).reversed() {
        let char = String(word[word.index(word.startIndex, offsetBy: i)])
        if vowels.contains(char) {
            closestVowel = char
            break
        }
    }
    
    for i in (0...word.count - 1).reversed() {
        let char = String(word[word.index(word.startIndex, offsetBy: i)])
        if consonants.contains(char) {
            if vowels.contains(char) {
                continue
            } else {
                closestVowel = ""
                break
            }
        }
    }
    
    return closestVowel
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    // your code here
    let vowels = "aeiouy"
    let consonants = "bcdfghjklmnpqrstvwxyz"
    var closestVowel = ""
    
    for i in (0...word.count - 1).reversed() {
        let char = String(word[word.index(word.startIndex, offsetBy: i)])
        if vowels.contains(char) {
            closestVowel = char
            break
        }
    }
    
    for i in (0...word.count - 1).reversed() {
        let char = String(word[word.index(word.startIndex, offsetBy: i)])
        if consonants.contains(char) {
            if vowels.contains(char) {
                continue
            } else {
                closestVowel = ""
                break
            }
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
  let vowels = ["a", "e", "i", "o", "u"]
  
  let consonants = word.filter { !vowels.contains($0) }
  
  var vowelIndex = 0
  
  for (index, char) in consonants.enumerated() {
    if vowels.contains(String(char)) {
      vowelIndex = index
      break
    }
  }
  
  let vowel = consonants[consonants.count - 1 - vowelIndex]
  
  if vowels.contains(vowel) {
    return String(vowel)
  } else {
    return ""
  }
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
  let vowels = ["a", "e", "i", "o", "u"]
  
  let consonants = word.filter { !vowels.contains($0) }
  
  var vowelIndex = 0
  
  for (index, char) in consonants.enumerated() {
    if vowels.contains(String(char)) {
      vowelIndex = index
      break
    }
  }
  
  let vowel = consonants[consonants.count - 1 - vowelIndex]
  
  if vowels.contains(vowel) {
    return String(vowel)
  } else {
    return ""
  }
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    let consonants = "bcdfghjklmnpqrstvwxyz"
    
    let wordArray = Array(word)
    let lastIndex = wordArray.count - 1
    
    var vowelFound = false
    var consonantFound = false
    var closestVowel = ""
    
    for (index, character) in wordArray.enumerated() {
        if vowels.contains(character) {
            vowelFound = true
            if consonantFound {
                closestVowel = String(character)
                break
            }
        }
        
        if consonants.contains(character) {
            consonantFound = true
        }
        
        if index == lastIndex {
            break
        }
    }
    
    return closestVowel
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = "aeiou"
    let consonants = "bcdfghjklmnpqrstvwxyz"
    
    let wordArray = Array(word)
    let lastIndex = wordArray.count - 1
    
    var vowelFound = false
    var consonantFound = false
    var closestVowel = ""
    
    for (index, character) in wordArray.enumerated() {
        if vowels.contains(character) {
            vowelFound = true
            if consonantFound {
                closestVowel = String(character)
                break
            }
        }
        
        if consonants.contains(character) {
            consonantFound = true
        }
        
        if index == lastIndex {
            break
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
  let vowels = ["a", "e", "i", "o", "u"]
  
  var closestVowel = ""
  
  for i in (0..<word.count).reversed() {
    let char = String(word[word.index(word.startIndex, offsetBy: i)])
    if vowels.contains(char) {
      closestVowel = char
      break
    }
  }
  
  return closestVowel
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
  let vowels = ["a", "e", "i", "o", "u"]
  
  var closestVowel = ""
  
  for i in (0..<word.count).reversed() {
    let char = String(word[word.index(word.startIndex, offsetBy: i)])
    if vowels.contains(char) {
      closestVowel = char
      break
    }
  }
  
  return closestVowel
}
```

func getClosestVowel(word: String) -> String {
  let vowels: [Character] = ["a", "e", "i", "o", "u"]
  var consonants: [Character] = []
  var vowelsFound: [Character] = []
  var closestVowel: Character = Character("")
  var closestVowelIndex = Int.max
  var wordArray = Array(word)
  for i in 0..<wordArray.count {
    if vowels.contains(wordArray[i]) {
      vowelsFound.append(wordArray[i])
    } else {
      consonants.append(wordArray[i])
    }
  }
  if consonants.count < 2 || vowelsFound.count == 0 {
    return ""
  }
  for i in 0..<consonants.count-1 {
    if consonants[i+1] == vowelsFound[0] {
      if i+1 < closestVowelIndex {
        closestVowel = consonants[i+1]
        closestVowelIndex = i+1
      }
    }
  }
  return String(closestVowel)
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
  let vowels: [Character] = ["a", "e", "i", "o", "u"]
  var consonants: [Character] = []
  var vowelsFound: [Character] = []
  var closestVowel: Character = Character("")
  var closestVowelIndex = Int.max
  var wordArray = Array(word)
  for i in 0..<wordArray.count {
    if vowels.contains(wordArray[i]) {
      vowelsFound.append(wordArray[i])
    } else {
      consonants.append(wordArray[i])
    }
  }
  if consonants.count < 2 || vowelsFound.count == 0 {
    return ""
  }
  for i in 0..<consonants.count-1 {
    if consonants[i+1] == vowelsFound[0] {
      if i+1 < closestVowelIndex {
        closestVowel = consonants[i+1]
        closestVowelIndex = i+1
      }
    }
  }
  return String(closestVowel)
}
```

func getClosestVowel(word: String) -> String {
    let vowels: [Character] = ["a", "e", "i", "o", "u"]
    let consonants: [Character] = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var closestVowel: Character = Character("")
    var closestVowelIndex: Int = -1
    var closestVowelDistance: Int = -1
    var vowelIndex: Int = -1
    var consonantIndex: Int = -1
    let wordArray = Array(word)
    for (index, character) in wordArray.enumerated() {
        if vowels.contains(character) {
            vowelIndex = index
            for (consonantIndex, character) in wordArray.enumerated() {
                if consonants.contains(character) {
                    if vowelIndex > consonantIndex {
                        let distance = vowelIndex - consonantIndex
                        if distance > closestVowelDistance {
                            closestVowel = character
                            closestVowelDistance = distance
                            closestVowelIndex = consonantIndex
                        }
                    }
                }
            }
        }
    }
    return String(closestVowel)
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels: [Character] = ["a", "e", "i", "o", "u"]
    let consonants: [Character] = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var closestVowel: Character = Character("")
    var closestVowelIndex: Int = -1
    var closestVowelDistance: Int = -1
    var vowelIndex: Int = -1
    var consonantIndex: Int = -1
    let wordArray = Array(word)
    for (index, character) in wordArray.enumerated() {
        if vowels.contains(character) {
            vowelIndex = index
            for (consonantIndex, character) in wordArray.enumerated() {
                if consonants.contains(character) {
                    if vowelIndex > consonantIndex {
                        let distance = vowelIndex - consonantIndex
                        if distance > closestVowelDistance {
                            closestVowel = character
                            closestVowelDistance = distance
                            closestVowelIndex = consonantIndex
                        }
                    }
                }
            }
        }
    }
    return String(closestVowel)
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var consonants = [String]()
    var vowelsIndex = [Int]()
    
    for (index, character) in word.enumerated() {
        if vowels.contains(String(character).lowercased()) {
            vowelsIndex.append(index)
        } else {
            consonants.append(String(character))
        }
    }
    
    if consonants.count < 2 || vowelsIndex.count < 2 {
        return ""
    }
    
    var closestVowelIndex = vowelsIndex[vowelsIndex.count - 2]
    for i in 0 ..< consonants.count - 1 {
        if consonants[i] != consonants[i + 1] {
            closestVowelIndex = vowelsIndex[vowelsIndex.count - 2]
            break
        }
    }
    
    return String(word[word.index(word.startIndex, offsetBy: closestVowelIndex)])
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var consonants = [String]()
    var vowelsIndex = [Int]()
    
    for (index, character) in word.enumerated() {
        if vowels.contains(String(character).lowercased()) {
            vowelsIndex.append(index)
        } else {
            consonants.append(String(character))
        }
    }
    
    if consonants.count < 2 || vowelsIndex.count < 2 {
        return ""
    }
    
    var closestVowelIndex = vowelsIndex[vowelsIndex.count - 2]
    for i in 0 ..< consonants.count - 1 {
        if consonants[i] != consonants[i + 1] {
            closestVowelIndex = vowelsIndex[vowelsIndex.count - 2]
            break
        }
    }
    
    return String(word[word.index(word.startIndex, offsetBy: closestVowelIndex)])
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var closestDistance = Double.maxFinite
    for i in 0..<word.length {
        let currentChar = word[i]
        if vowels.contains(currentChar.uppercase()) {
            let distance = i
            closestDistance = distance
            closestVowel = currentChar
        }
        if i > 0 {
            let previousChar = word[i - 1]
            if vowels.contains(previousChar.uppercase()) {
                let distance = i - 1
                if distance < closestDistance {
                    closestDistance = distance
                    closestVowel = currentChar
                }
            }
        }
    }
    return closestVowel
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var closestDistance = Double.maxFinite
    for i in 0..<word.length {
        let currentChar = word[i]
        if vowels.contains(currentChar.uppercase()) {
            let distance = i
            closestDistance = distance
            closestVowel = currentChar
        }
        if i > 0 {
            let previousChar = word[i - 1]
            if vowels.contains(previousChar.uppercase()) {
                let distance = i - 1
                if distance < closestDistance {
                    closestDistance = distance
                    closestVowel = currentChar
                }
            }
        }
    }
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var word = word.uppercase()
    var i = word.lastIndex
    var j = word.lastIndex
    var result = ""
    while i >= 0 {
        if word[i] in vowels {
            result = word[i]
            break
        }
        if word[i] in consonants {
            j = i
        }
        i -= 1
    }
    if result == "" {
        return ""
    }
    var i = j
    while i >= 0 {
        if word[i] in vowels {
            return result
        }
        i -= 1
    }
    return result
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var word = word.uppercase()
    var i = word.lastIndex
    var j = word.lastIndex
    var result = ""
    while i >= 0 {
        if word[i] in vowels {
            result = word[i]
            break
        }
        if word[i] in consonants {
            j = i
        }
        i -= 1
    }
    if result == "" {
        return ""
    }
    var i = j
    while i >= 0 {
        if word[i] in vowels {
            return result
        }
        i -= 1
    }
    return result
}
```

func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var vowelsIndex = [Int]()
    var consonantsIndex = [Int]()
    var word = word.lowercase()
    var wordLength = word.length
    for i in 0..<wordLength {
        if vowels.contains(word[i]) {
            vowelsIndex.append(i)
        } else if consonants.contains(word[i]) {
            consonantsIndex.append(i)
        }
    }
    if vowelsIndex.isEmpty || consonantsIndex.isEmpty {
        return ""
    }
    var vowelsIndexLength = vowelsIndex.length
    var consonantsIndexLength = consonantsIndex.length
    var vowelsIndexLast = vowelsIndex[vowelsIndexLength - 1]
    var consonantsIndexLast = consonantsIndex[consonantsIndexLength - 1]
    var vowelsIndexFirst = vowelsIndex[0]
    var consonantsIndexFirst = consonantsIndex[0]
    var vowelsIndexLastIndex = vowelsIndexLength - 1
    var consonantsIndexLastIndex = consonantsIndexLength - 1
    var vowelsIndexFirstIndex = 0
    var consonantsIndexFirstIndex = 0
    var closestVowel = ""
    var closestVowelDistance = Int.max_value
    var closestVowelIndex = 0
    for i in 0..<consonantsIndexLastIndex {
        var consonantIndex = consonantsIndex[i]
        var consonant = word[consonantIndex]
        for j in vowelsIndexFirstIndex..<vowelsIndexLastIndex {
            var vowelIndex = vowelsIndex[j]
            var vowel = word[vowelIndex]
            if consonant < vowel {
                var vowelDistance = vowelIndex - consonantIndex
                if vowelDistance < closestVowelDistance {
                    closestVowel = vowel
                    closestVowelDistance = vowelDistance
                    closestVowelIndex = vowelIndex
                }
                break
            }
        }
    }
    return closestVowel
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var vowelsIndex = [Int]()
    var consonantsIndex = [Int]()
    var word = word.lowercase()
    var wordLength = word.length
    for i in 0..<wordLength {
        if vowels.contains(word[i]) {
            vowelsIndex.append(i)
        } else if consonants.contains(word[i]) {
            consonantsIndex.append(i)
        }
    }
    if vowelsIndex.isEmpty || consonantsIndex.isEmpty {
        return ""
    }
    var vowelsIndexLength = vowelsIndex.length
    var consonantsIndexLength = consonantsIndex.length
    var vowelsIndexLast = vowelsIndex[vowelsIndexLength - 1]
    var consonantsIndexLast = consonantsIndex[consonantsIndexLength - 1]
    var vowelsIndexFirst = vowelsIndex[0]
    var consonantsIndexFirst = consonantsIndex[0]
    var vowelsIndexLastIndex = vowelsIndexLength - 1
    var consonantsIndexLastIndex = consonantsIndexLength - 1
    var vowelsIndexFirstIndex = 0
    var consonantsIndexFirstIndex = 0
    var closestVowel = ""
    var closestVowelDistance = Int.max_value
    var closestVowelIndex = 0
    for i in 0..<consonantsIndexLastIndex {
        var consonantIndex = consonantsIndex[i]
        var consonant = word[consonantIndex]
        for j in vowelsIndexFirstIndex..<vowelsIndexLastIndex {
            var vowelIndex = vowelsIndex[j]
            var vowel = word[vowelIndex]
            if consonant < vowel {
                var vowelDistance = vowelIndex - consonantIndex
                if vowelDistance < closestVowelDistance {
                    closestVowel = vowel
                    closestVowelDistance = vowelDistance
                    closestVowelIndex = vowelIndex
                }
                break
            }
        }
    }
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var closestDistance = 0
    var lastConsonantIndex = 0
    var lastVowelIndex = 0
    for i in 0..<word.length {
        let currentChar = word[i]
        if vowels.contains(currentChar) {
            if i > lastConsonantIndex {
                let distance = i - lastConsonantIndex
                if distance > closestDistance {
                    closestVowel = currentChar
                    closestDistance = distance
                }
            }
            lastVowelIndex = i
        } else {
            lastConsonantIndex = i
        }
    }
    return closestVowel
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var closestDistance = 0
    var lastConsonantIndex = 0
    var lastVowelIndex = 0
    for i in 0..<word.length {
        let currentChar = word[i]
        if vowels.contains(currentChar) {
            if i > lastConsonantIndex {
                let distance = i - lastConsonantIndex
                if distance > closestDistance {
                    closestVowel = currentChar
                    closestDistance = distance
                }
            }
            lastVowelIndex = i
        } else {
            lastConsonantIndex = i
        }
    }
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    var vowels: String = "aeiou"
    var closestVowel: String = ""
    var lastConsonantIndex: Int = 0
    var lastVowelIndex: Int = 0
    var currentVowelIndex: Int = 0
    var currentConsonantIndex: Int = 0
    for i in 0..<word.count {
        var currentChar: Char = word[i]
        if vowels.contains(currentChar) {
            currentVowelIndex = i
            if closestVowel == "" {
                closestVowel = currentChar.uppercaseString
            } else {
                if currentChar.uppercaseString.compare(closestVowel) < 0 {
                    closestVowel = currentChar.uppercaseString
                }
            }
        } else {
            currentConsonantIndex = i
            if lastConsonantIndex == 0 {
                lastConsonantIndex = currentConsonantIndex
            }
            if lastVowelIndex == 0 {
                lastVowelIndex = currentVowelIndex
            }
        }
    }
    if closestVowel == "" {
        return ""
    } else {
        return closestVowel
    }
}

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowels: String = "aeiou"
    var closestVowel: String = ""
    var lastConsonantIndex: Int = 0
    var lastVowelIndex: Int = 0
    var currentVowelIndex: Int = 0
    var currentConsonantIndex: Int = 0
    for i in 0..<word.count {
        var currentChar: Char = word[i]
        if vowels.contains(currentChar) {
            currentVowelIndex = i
            if closestVowel == "" {
                closestVowel = currentChar.uppercaseString
            } else {
                if currentChar.uppercaseString.compare(closestVowel) < 0 {
                    closestVowel = currentChar.uppercaseString
                }
            }
        } else {
            currentConsonantIndex = i
            if lastConsonantIndex == 0 {
                lastConsonantIndex = currentConsonantIndex
            }
            if lastVowelIndex == 0 {
                lastVowelIndex = currentVowelIndex
            }
        }
    }
    if closestVowel == "" {
        return ""
    } else {
        return closestVowel
    }
}
```

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowels: String = "aeiou"
    var consonant: String = "bcdfghjklmnpqrstvwxyz"
    var word: String = word.uppercase()
    var closestVowel: String = ""
    var closestDistance: Int = Int.max_value
    var currentDistance: Int = 0
    var currentConsonant: String = ""
    var currentVowel: String = ""
    var currentPosition: Int = 0
    var currentVowelPosition: Int = 0
    var currentConsonantPosition: Int = 0
    var currentConsonantDistance: Int = 0
    var currentVowelDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentVowelDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int = 0
    var currentConsonantDistance: Int

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowels: [String] = ["a", "e", "i", "o", "u"]
    var consonants: [String] = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var result: String = ""
    var i: Int = 0
    var j: Int = 0
    var k: Int = 0
    var l: Int = 0
    var m: Int = 0
    var n: Int = 0
    var o: Int = 0
    var p: Int = 0
    var q: Int = 0
    var r: Int = 0
    var s: Int = 0
    var t: Int = 0
    var u: Int = 0
    var v: Int = 0
    var w: Int = 0
    var x: Int = 0
    var y: Int = 0
    var z: Int = 0
    var a: Int = 0
    var b: Int = 0
    var c: Int = 0
    var d: Int = 0
    var e: Int = 0
    var f: Int = 0
    var g: Int = 0
    var h: Int = 0
    var j: Int = 0
    var k: Int = 0
    var l: Int = 0
    var m: Int = 0
    var n: Int = 0
    var p: Int = 0
    var q: Int = 0
    var r: Int = 0
    var s: Int = 0
    var t: Int = 0
    var v: Int = 0
    var w: Int = 0
    var x: Int = 0
    var y: Int = 0
    var z: Int = 0
    var a: Int = 0
    var b: Int = 0
    var c: Int = 0
    var d: Int = 0
    var e: Int = 0
    var f: Int = 0
    var g: Int = 0
    var h: Int = 0
    var j: Int = 0
    var k: Int = 0
    var l: Int = 0
    var m: Int = 0
    var n: Int = 0
    var p: Int = 0
    var q: Int = 0
    var r: Int = 0
    var s: Int = 0
    var t: Int = 0
    var v: Int = 0
    var w: Int = 0
    var x: Int = 0
    var y: Int = 0
    var z: Int = 0
    var a: Int = 0
    var b: Int = 0
    var c: Int = 0
    var d: Int = 0
    var e: Int = 0
    var f: Int = 0
    var g: Int = 0
    var h: Int = 0
    var j: Int = 0
    var k: Int = 0
    var l: Int = 0
    var m: Int = 0
    var n: Int = 0
    var p: Int = 0
    var q: Int = 0
    var r: Int = 0
    var s: Int = 0
    var t: Int = 0
    var v: Int = 0
    var w: Int = 0
    var x: Int = 0
    var y: Int = 0
    var z: Int = 0
    var a: Int = 0
    var b: Int = 0
    var c: Int = 0
    var d: Int = 0
    var e: Int = 0
    var f: Int = 0
    var g: Int = 0
    var h: Int = 0
    var j: Int = 0
    var k: Int = 0
    var l: Int = 0
    var m: Int = 0
    var n: Int = 0
    var p: Int = 0
    var q: Int = 0
    

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var vowelsIndex = []Int{}
    var consonantsIndex = []Int{}
    var vowelsDistance = []Int{}
    var consonantsDistance = []Int{}
    var distance = 0
    var minDistance = 1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var closestVowel = ""
    var closestDistance = Double.maxFinite
    var wordLength = word.length
    var wordReversed = word.reversed
    var wordReversedWithoutVowels = ""
    var wordReversedWithoutVowelsAndConsonants = ""
    var wordReversedWithoutVowelsAndConsonantsArray = [String]()
    var wordReversedWithoutVowelsAndConsonantsArrayReversed = [String]()
    var wordReversedWithoutVowelsAndConsonantsArrayReversedWithoutEmptyStrings = [String]()
    var wordReversedWithoutVowelsAndConsonantsArrayReversedWithoutEmptyStringsWithoutConsonants = [String]()
    var wordReversedWithoutVowelsAndConsonantsArrayReversedWithoutEmptyStringsWithoutConsonantsReversed = [String]()
    var wordReversedWithoutVowelsAndConsonantsArrayReversedWithoutEmptyStringsWithoutConsonantsReversedWithoutEmptyStrings = [String]()
    var wordReversedWithoutVowelsAndConsonantsArrayReversedWithoutEmptyStringsWithoutConsonantsReversedWithoutEmptyStringsReversed = [String]()
    var wordReversedWithoutVowelsAndConsonantsArrayReversedWithoutEmptyStringsWithoutConsonantsReversedWithoutEmptyStringsReversedWithoutEmptyStrings = [String]()
    var wordReversedWithoutVowelsAndConsonantsArrayReversedWithoutEmptyStringsWithoutConsonantsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversed = [String]()
    var wordReversedWithoutVowelsAndConsonantsArrayReversedWithoutEmptyStringsWithoutConsonantsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStrings = [String]()
    var wordReversedWithoutVowelsAndConsonantsArrayReversedWithoutEmptyStringsWithoutConsonantsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversed = [String]()
    var wordReversedWithoutVowelsAndConsonantsArrayReversedWithoutEmptyStringsWithoutConsonantsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStrings = [String]()
    var wordReversedWithoutVowelsAndConsonantsArrayReversedWithoutEmptyStringsWithoutConsonantsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversed = [String]()
    var wordReversedWithoutVowelsAndConsonantsArrayReversedWithoutEmptyStringsWithoutConsonantsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStrings = [String]()
    var wordReversedWithoutVowelsAndConsonantsArrayReversedWithoutEmptyStringsWithoutConsonantsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStrings = [String]()
    var wordReversedWithoutVowelsAndConsonantsArrayReversedWithoutEmptyStringsWithoutConsonantsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStrings = [String]()
    var wordReversedWithoutVowelsAndConsonantsArrayReversedWithoutEmptyStringsWithoutConsonantsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStrings = [String]()
    var wordReversedWithoutVowelsAndConsonantsArrayReversedWithoutEmptyStringsWithoutConsonantsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStrings = [String]()
    var wordReversedWithoutVowelsAndConsonantsArrayReversedWithoutEmptyStringsWithoutConsonantsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStrings = [String]()
    var wordReversedWithoutVowelsAndConsonantsArrayReversedWithoutEmptyStringsWithoutConsonantsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStrings = [String]()
    var wordReversedWithoutVowelsAndConsonantsArrayReversedWithoutEmptyStringsWithoutConsonantsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversedWithoutEmptyStringsReversed

```swift
// You are given a word. Your task is to find the closest vowel that stands between 
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any vowel met the above condition. 
// You may assume that the given string contains English letter only.
// Example:
// getClosestVowel(word: "yogurt") == "u"
// getClosestVowel(word: "FULL") == "U"
// getClosestVowel(word: "quick") == ""
// getClosestVowel(word: "ab") == ""
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let vowelsIndex = vowels.map { $0.indexIn(word) }
    let vowelsIndexes = vowelsIndex.filter { $0 != nil }
    let vowelsIndexesSorted = vowelsIndexes.sorted()
    let vowelsIndexesSortedReversed = vowelsIndexesSorted.reversed()
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != word.length }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != 0 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 != -1 }
    let vowelsIndexesSortedReversed = vowelsIndexesSortedReversed.filter { $0 !=

func getClosestVowel(word: String) -> String {
    guard word.count > 2 else { return "" }
    
    let vowels: Set<Character> = ["a", "e", "i", "o", "u"]
    
    for (index, char) in word.enumerated() {
        if vowels.contains(char) {
            if index < word.count - 1 {
                if !vowels.contains(word[word.index(after: index)]) {
                    return String(char)
                }
            }
        }
    }
    
    return ""
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<end_of_turn>
<start_of_turn>model
```swift
func getClosestVowel(word: String) -> String {
    guard word.count > 2 else { return "" }
    
    let vowels: Set<Character> = ["a", "e", "i", "o", "u"]
    
    for (index, char) in word.enumerated() {
        if vowels.contains(char) {
            if index < word.count - 1 {
                if !vowels.contains(word[word.index(after: index)]) {
                    return String(char)
                }
            }
        }
    }
    
    return ""
}
```

func getClosestVowel(word: String) -> String {
    guard word.count > 2 else { return "" }
    var consonants = [Character]()
    var vowels = [Character]()
    for (index, character) in word.enumerated() {
        if character.isVowel {
            vowels.append(character)
        } else {
            consonants.append(character)
        }
        if consonants.count >= 2 && vowels.count >= 1 {
            if index > consonants.count - 2 {
                return vowels.last!
            } else {
                return vowels[vowels.count - 1]
            }
        }
    }
    return ""
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<end_of_turn>
<start_of_turn>model
```swift
func getClosestVowel(word: String) -> String {
    guard word.count > 2 else { return "" }
    var consonants = [Character]()
    var vowels = [Character]()
    for (index, character) in word.enumerated() {
        if character.isVowel {
            vowels.append(character)
        } else {
            consonants.append(character)
        }
        if consonants.count >= 2 && vowels.count >= 1 {
            if index > consonants.count - 2 {
                return vowels.last!
            } else {
                return vowels[vowels.count - 1]
            }
        }
    }
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var consonants = [Character]()
    var vowelsFound = [Character]()
    var closestVowel: Character?
    
    for (index, char) in word.lowercased().enumerated() {
        if consonants.isEmpty && vowels.contains(char) {
            consonants.append(char)
        } else if consonants.count == 2 && vowels.contains(char) {
            vowelsFound.append(char)
            closestVowel = char
        } else if consonants.count == 2 {
            consonants.removeFirst()
        }
    }
    
    if let closestVowel = closestVowel {
        return String(closestVowel)
    } else {
        return ""
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<end_of_turn>
<start_of_turn>model
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var consonants = [Character]()
    var vowelsFound = [Character]()
    var closestVowel: Character?
    
    for (index, char) in word.lowercased().enumerated() {
        if consonants.isEmpty && vowels.contains(char) {
            consonants.append(char)
        } else if consonants.count == 2 && vowels.contains(char) {
            vowelsFound.append(char)
            closestVowel = char
        } else if consonants.count == 2 {
            consonants.removeFirst()
        }
    }
    
    if let closestVowel = closestVowel {
        return String(closestVowel)
    } else {
        return ""
    }
}
```

func getClosestVowel(word: String) -> String {
    var lastConsonantIndex: Int?
    var lastVowelIndex: Int?
    
    for (index, character) in word.enumerated() {
        if character.isVowel {
            lastVowelIndex = index
        } else if lastConsonantIndex == nil {
            lastConsonantIndex = index
        }
    }
    
    guard let lastConsonantIndex = lastConsonantIndex, let lastVowelIndex = lastVowelIndex else {
        return ""
    }
    
    if lastConsonantIndex > lastVowelIndex {
        return ""
    }
    
    for (index, character) in word.enumerated().reversed() {
        if index <= lastConsonantIndex {
            continue
        }
        
        if character.isVowel {
            return String(character)
        }
    }
    
    return ""
}

extension Character {
    var isVowel: Bool {
        switch self.lowercased() {
        case "a", "e", "i", "o", "u":
            return true
        default:
            return false
        }
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<end_of_turn>
<start_of_turn>model
```swift
func getClosestVowel(word: String) -> String {
    var lastConsonantIndex: Int?
    var lastVowelIndex: Int?
    
    for (index, character) in word.enumerated() {
        if character.isVowel {
            lastVowelIndex = index
        } else if lastConsonantIndex == nil {
            lastConsonantIndex = index
        }
    }
    
    guard let lastConsonantIndex = lastConsonantIndex, let lastVowelIndex = lastVowelIndex else {
        return ""
    }
    
    if lastConsonantIndex > lastVowelIndex {
        return ""
    }
    
    for (index, character) in word.enumerated().reversed() {
        if index <= lastConsonantIndex {
            continue
        }
        
        if character.isVowel {
            return String(character)
        }
    }
    
    return ""
}

extension Character {
    var isVowel: Bool {
        switch self.lowercased() {
        case "a", "e", "i", "o", "u":
            return true
        default:
            return false
        }
    }
}
```

func getClosestVowel(word: String) -> String {
    let vowels: Set<Character> = ["a", "e", "i", "o", "u"]
    var consonants: [Character] = []
    var vowelsFound: [Character] = []
    
    for (index, char) in word.enumerated() {
        if consonants.isEmpty && vowels.contains(char) {
            vowelsFound.append(char)
        } else if consonants.isEmpty {
            consonants.append(char)
        } else if vowels.contains(char) {
            consonants.append(char)
            if consonants.count == 2 {
                if let lastVowel = vowelsFound.last {
                    return String(lastVowel)
                }
                consonants.removeFirst()
            }
        }
    }
    
    return ""
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<end_of_turn>
<start_of_turn>model
```swift
func getClosestVowel(word: String) -> String {
    let vowels: Set<Character> = ["a", "e", "i", "o", "u"]
    var consonants: [Character] = []
    var vowelsFound: [Character] = []
    
    for (index, char) in word.enumerated() {
        if consonants.isEmpty && vowels.contains(char) {
            vowelsFound.append(char)
        } else if consonants.isEmpty {
            consonants.append(char)
        } else if vowels.contains(char) {
            consonants.append(char)
            if consonants.count == 2 {
                if let lastVowel = vowelsFound.last {
                    return String(lastVowel)
                }
                consonants.removeFirst()
            }
        }
    }
    
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var consonants = [String]()
    var vowelsFound = [String]()
    
    for (index, character) in word.enumerated() {
        if vowels.contains(String(character).lowercased()) {
            vowelsFound.append(String(character).lowercased())
        } else {
            consonants.append(String(character).lowercased())
        }
        
        if consonants.count >= 2 && vowelsFound.count >= 1 {
            if index + 1 < word.count && vowels.contains(String(word[index + 1]).lowercased()) {
                return vowelsFound.last!
            }
        }
    }
    
    return ""
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<end_of_turn>
<start_of_turn>model
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var consonants = [String]()
    var vowelsFound = [String]()
    
    for (index, character) in word.enumerated() {
        if vowels.contains(String(character).lowercased()) {
            vowelsFound.append(String(character).lowercased())
        } else {
            consonants.append(String(character).lowercased())
        }
        
        if consonants.count >= 2 && vowelsFound.count >= 1 {
            if index + 1 < word.count && vowels.contains(String(word[index + 1]).lowercased()) {
                return vowelsFound.last!
            }
        }
    }
    
    return ""
}
```

func getClosestVowel(word: String) -> String {
    guard word.count > 2 else { return "" }
    var vowels = "aeiouAEIOU"
    var consonants = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
    var closestVowel = ""
    var lastConsonantIndex = -1
    var lastVowelIndex = -1
    for (index, char) in word.enumerated() {
        if consonants.contains(char) {
            lastConsonantIndex = index
        } else if vowels.contains(char) {
            lastVowelIndex = index
            if lastConsonantIndex != -1 && lastConsonantIndex != lastVowelIndex {
                closestVowel = String(char)
            }
        }
    }
    return closestVowel
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<end_of_turn>
<start_of_turn>model
```swift
func getClosestVowel(word: String) -> String {
    guard word.count > 2 else { return "" }
    var vowels = "aeiouAEIOU"
    var consonants = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
    var closestVowel = ""
    var lastConsonantIndex = -1
    var lastVowelIndex = -1
    for (index, char) in word.enumerated() {
        if consonants.contains(char) {
            lastConsonantIndex = index
        } else if vowels.contains(char) {
            lastVowelIndex = index
            if lastConsonantIndex != -1 && lastConsonantIndex != lastVowelIndex {
                closestVowel = String(char)
            }
        }
    }
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels: Set<Character> = ["a", "e", "i", "o", "u"]
    var consonants: [Character] = []
    var closestVowel: Character?

    for (index, character) in word.reversed().enumerated() {
        if consonants.count == 2 {
            break
        }
        if vowels.contains(character) {
            closestVowel = character
        } else if !vowels.contains(character) {
            consonants.append(character)
        }
    }

    return closestVowel ?? ""
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<end_of_turn>
<start_of_turn>model
```swift
func getClosestVowel(word: String) -> String {
    let vowels: Set<Character> = ["a", "e", "i", "o", "u"]
    var consonants: [Character] = []
    var closestVowel: Character?

    for (index, character) in word.reversed().enumerated() {
        if consonants.count == 2 {
            break
        }
        if vowels.contains(character) {
            closestVowel = character
        } else if !vowels.contains(character) {
            consonants.append(character)
        }
    }

    return closestVowel ?? ""
}
```

func getClosestVowel(word: String) -> String {
    guard word.count > 2 else { return "" }
    
    var consonants = [Character]()
    var vowels = [Character]()
    
    for (index, character) in word.enumerated() {
        if character.isVowel {
            vowels.append(character)
        } else {
            consonants.append(character)
        }
        
        if consonants.count >= 2 && vowels.count >= 1 && index + 1 < word.count {
            if consonants.last! > vowels.last! && consonants[consonants.count - 2] < vowels.last! {
                return String(vowels.last!)
            }
        }
    }
    
    return ""
}

extension Character {
    var isVowel: Bool {
        switch self.lowercased() {
        case "a", "e", "i", "o", "u":
            return true
        default:
            return false
        }
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<end_of_turn>
<start_of_turn>model
```swift
func getClosestVowel(word: String) -> String {
    guard word.count > 2 else { return "" }
    
    var consonants = [Character]()
    var vowels = [Character]()
    
    for (index, character) in word.enumerated() {
        if character.isVowel {
            vowels.append(character)
        } else {
            consonants.append(character)
        }
        
        if consonants.count >= 2 && vowels.count >= 1 && index + 1 < word.count {
            if consonants.last! > vowels.last! && consonants[consonants.count - 2] < vowels.last! {
                return String(vowels.last!)
            }
        }
    }
    
    return ""
}

extension Character {
    var isVowel: Bool {
        switch self.lowercased() {
        case "a", "e", "i", "o", "u":
            return true
        default:
            return false
        }
    }
}
```

func getClosestVowel(word: String) -> String {
    guard word.count > 2 else { return "" }
    let vowels = ["a", "e", "i", "o", "u"]
    var consonantsCount = 0
    var result: String?
    for char in word.reversed() {
        if consonantsCount >= 2 {
            if vowels.contains(String(char)) {
                result = String(char)
                break
            }
        } else if !vowels.contains(String(char)) {
            consonantsCount += 1
        }
    }
    return result ?? ""
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<end_of_turn>
<start_of_turn>model
```swift
func getClosestVowel(word: String) -> String {
    guard word.count > 2 else { return "" }
    let vowels = ["a", "e", "i", "o", "u"]
    var consonantsCount = 0
    var result: String?
    for char in word.reversed() {
        if consonantsCount >= 2 {
            if vowels.contains(String(char)) {
                result = String(char)
                break
            }
        } else if !vowels.contains(String(char)) {
            consonantsCount += 1
        }
    }
    return result ?? ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let characters = Array(word.lowercased())
    var consonantsCount = 0
    var closestVowel: String?

    for i in stride(from: characters.count - 1, through: 0, by: -1) {
        if vowels.contains(characters[i]) {
            closestVowel = characters[i]
            break
        } else if !vowels.contains(characters[i]) {
            consonantsCount += 1
            if consonantsCount == 2 {
                break
            }
        }
    }

    return closestVowel ?? ""
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<end_of_turn>
<start_of_turn>model
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let characters = Array(word.lowercased())
    var consonantsCount = 0
    var closestVowel: String?

    for i in stride(from: characters.count - 1, through: 0, by: -1) {
        if vowels.contains(characters[i]) {
            closestVowel = characters[i]
            break
        } else if !vowels.contains(characters[i]) {
            consonantsCount += 1
            if consonantsCount == 2 {
                break
            }
        }
    }

    return closestVowel ?? ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let letters = Array(word.lowercased())
    
    for (index, letter) in letters.enumerated() {
        if vowels.contains(letter) {
            if letters[max(0, index - 1)] != letters[index] && letters[min(letters.count - 1, index + 1)] != letters[index] {
                return String(letter)
            }
        }
    }
    
    return ""
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<end_of_turn>
<start_of_turn>model
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let letters = Array(word.lowercased())
    
    for (index, letter) in letters.enumerated() {
        if vowels.contains(letter) {
            if letters[max(0, index - 1)] != letters[index] && letters[min(letters.count - 1, index + 1)] != letters[index] {
                return String(letter)
            }
        }
    }
    
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let letters = Array(word)
    var consonantsCount = 0
    var closestVowel = ""

    for i in stride(from: letters.count - 1, through: 0, by: -1) {
        let letter = letters[i]

        if letter.isVowel {
            if consonantsCount >= 2 {
                closestVowel = letter.description
                break
            }
            consonantsCount = 0
        } else {
            consonantsCount += 1
        }
    }

    return closestVowel
}

extension Character {
    var isVowel: Bool {
        return ["a", "e", "i", "o", "u"].contains(self.lowercased())
    }
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<end_of_turn>
<start_of_turn>model
```swift
func getClosestVowel(word: String) -> String {
    let letters = Array(word)
    var consonantsCount = 0
    var closestVowel = ""

    for i in stride(from: letters.count - 1, through: 0, by: -1) {
        let letter = letters[i]

        if letter.isVowel {
            if consonantsCount >= 2 {
                closestVowel = letter.description
                break
            }
            consonantsCount = 0
        } else {
            consonantsCount += 1
        }
    }

    return closestVowel
}

extension Character {
    var isVowel: Bool {
        return ["a", "e", "i", "o", "u"].contains(self.lowercased())
    }
}
```

func getClosestVowel(word: String) -> String {
    let letters = Array(word)
    var consonantsCount = 0
    var closestVowel = ""
    
    for i in stride(from: letters.count - 1, through: 0, by: -1) {
        let letter = letters[i]
        if letter == "a" || letter == "e" || letter == "i" || letter == "o" || letter == "u" {
            continue
        } else if letter.isLetter {
            consonantsCount += 1
            if consonantsCount == 2 {
                closestVowel = String(letter)
                break
            }
        }
    }
    
    return closestVowel
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<end_of_turn>
<start_of_turn>model
```swift
func getClosestVowel(word: String) -> String {
    let letters = Array(word)
    var consonantsCount = 0
    var closestVowel = ""
    
    for i in stride(from: letters.count - 1, through: 0, by: -1) {
        let letter = letters[i]
        if letter == "a" || letter == "e" || letter == "i" || letter == "o" || letter == "u" {
            continue
        } else if letter.isLetter {
            consonantsCount += 1
            if consonantsCount == 2 {
                closestVowel = String(letter)
                break
            }
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels: Set<Character> = ["a", "e", "i", "o", "u"]
    let letters = Array(word.lowercased())
    var consonantsCount = 0
    var closestVowel: Character?

    for i in stride(from: letters.count - 1, through: 0, by: -1) {
        if vowels.contains(letters[i]) {
            closestVowel = letters[i]
            break
        } else if !vowels.contains(letters[i]) {
            consonantsCount += 1
        }

        if consonantsCount == 2 {
            return String(closestVowel!)
        }
    }

    return ""
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<end_of_turn>
<start_of_turn>model
```swift
func getClosestVowel(word: String) -> String {
    let vowels: Set<Character> = ["a", "e", "i", "o", "u"]
    let letters = Array(word.lowercased())
    var consonantsCount = 0
    var closestVowel: Character?

    for i in stride(from: letters.count - 1, through: 0, by: -1) {
        if vowels.contains(letters[i]) {
            closestVowel = letters[i]
            break
        } else if !vowels.contains(letters[i]) {
            consonantsCount += 1
        }

        if consonantsCount == 2 {
            return String(closestVowel!)
        }
    }

    return ""
}
```

func getClosestVowel(word: String) -> String {
    let letters = Array(word)
    var consonantsCount = 0
    var closestVowel: Character?
    
    for i in stride(from: letters.count - 1, through: 0, by: -1) {
        let letter = letters[i]
        if isVowel(letter) {
            closestVowel = letter
            continue
        }
        if isConsonant(letter) {
            consonantsCount += 1
            if consonantsCount == 2 {
                return String(closestVowel!)
            }
        }
    }
    
    return ""
}

func isVowel(_ letter: Character) -> Bool {
    return ["a", "e", "i", "o", "u"].contains(String(letter).lowercased())
}

func isConsonant(_ letter: Character) -> Bool {
    return !isVowel(letter)
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<end_of_turn>
<start_of_turn>model
```swift
func getClosestVowel(word: String) -> String {
    let letters = Array(word)
    var consonantsCount = 0
    var closestVowel: Character?
    
    for i in stride(from: letters.count - 1, through: 0, by: -1) {
        let letter = letters[i]
        if isVowel(letter) {
            closestVowel = letter
            continue
        }
        if isConsonant(letter) {
            consonantsCount += 1
            if consonantsCount == 2 {
                return String(closestVowel!)
            }
        }
    }
    
    return ""
}

func isVowel(_ letter: Character) -> Bool {
    return ["a", "e", "i", "o", "u"].contains(String(letter).lowercased())
}

func isConsonant(_ letter: Character) -> Bool {
    return !isVowel(letter)
}
```

func getClosestVowel(word: String) -> String {
    let letters = Array(word)
    var consonantsCount = 0
    var closestVowel = ""

    for i in stride(from: letters.count - 1, through: 0, by: -1) {
        let letter = letters[i]

        if letter == "a" || letter == "e" || letter == "i" || letter == "o" || letter == "u" {
            if consonantsCount >= 2 {
                closestVowel = letter
                break
            }
            consonantsCount += 1
        } else if letter != "a" && letter != "e" && letter != "i" && letter != "o" && letter != "u" {
            consonantsCount += 1
        }
    }

    return closestVowel
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<end_of_turn>
<start_of_turn>model
```swift
func getClosestVowel(word: String) -> String {
    let letters = Array(word)
    var consonantsCount = 0
    var closestVowel = ""

    for i in stride(from: letters.count - 1, through: 0, by: -1) {
        let letter = letters[i]

        if letter == "a" || letter == "e" || letter == "i" || letter == "o" || letter == "u" {
            if consonantsCount >= 2 {
                closestVowel = letter
                break
            }
            consonantsCount += 1
        } else if letter != "a" && letter != "e" && letter != "i" && letter != "o" && letter != "u" {
            consonantsCount += 1
        }
    }

    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels: Set<Character> = ["a", "e", "i", "o", "u"]
    let letters = Array(word.lowercased())
    var consonantsCount = 0
    var closestVowel: Character?
    
    for i in stride(from: letters.count - 1, through: 0, by: -1) {
        if vowels.contains(letters[i]) {
            closestVowel = letters[i]
            break
        } else if !vowels.contains(letters[i]) {
            consonantsCount += 1
        }
        
        if consonantsCount == 2 {
            return String(closestVowel!)
        }
    }
    
    return ""
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<end_of_turn>
<start_of_turn>model
```swift
func getClosestVowel(word: String) -> String {
    let vowels: Set<Character> = ["a", "e", "i", "o", "u"]
    let letters = Array(word.lowercased())
    var consonantsCount = 0
    var closestVowel: Character?
    
    for i in stride(from: letters.count - 1, through: 0, by: -1) {
        if vowels.contains(letters[i]) {
            closestVowel = letters[i]
            break
        } else if !vowels.contains(letters[i]) {
            consonantsCount += 1
        }
        
        if consonantsCount == 2 {
            return String(closestVowel!)
        }
    }
    
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let letters = Array(word)
    var consonantsCount = 0
    var closestVowel: Character?

    for i in stride(from: letters.count - 1, through: 0, by: -1) {
        let letter = letters[i]

        if letter == "a" || letter == "e" || letter == "i" || letter == "o" || letter == "u" {
            closestVowel = letter
        } else if letter != "a" && letter != "e" && letter != "i" && letter != "o" && letter != "u" {
            consonantsCount += 1
        }

        if consonantsCount == 2 {
            return String(closestVowel!)
        }
    }

    return ""
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<end_of_turn>
<start_of_turn>model
```swift
func getClosestVowel(word: String) -> String {
    let letters = Array(word)
    var consonantsCount = 0
    var closestVowel: Character?

    for i in stride(from: letters.count - 1, through: 0, by: -1) {
        let letter = letters[i]

        if letter == "a" || letter == "e" || letter == "i" || letter == "o" || letter == "u" {
            closestVowel = letter
        } else if letter != "a" && letter != "e" && letter != "i" && letter != "o" && letter != "u" {
            consonantsCount += 1
        }

        if consonantsCount == 2 {
            return String(closestVowel!)
        }
    }

    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let characters = Array(word.lowercased())
    
    for i in stride(from: characters.count - 1, through: 1, by: -1) {
        if vowels.contains(String(characters[i])) {
            var leftConsonantFound = false
            var rightConsonantFound = false
            
            for j in stride(from: i - 1, through: 0, by: -1) {
                if !vowels.contains(String(characters[j])) {
                    leftConsonantFound = true
                    break
                }
            }
            
            for j in stride(from: i + 1, through: characters.count - 1, by: 1) {
                if !vowels.contains(String(characters[j])) {
                    rightConsonantFound = true
                    break
                }
            }
            
            if leftConsonantFound && rightConsonantFound {
                return String(characters[i])
            }
        }
    }
    
    return ""
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""<end_of_turn>
<start_of_turn>model
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let characters = Array(word.lowercased())
    
    for i in stride(from: characters.count - 1, through: 1, by: -1) {
        if vowels.contains(String(characters[i])) {
            var leftConsonantFound = false
            var rightConsonantFound = false
            
            for j in stride(from: i - 1, through: 0, by: -1) {
                if !vowels.contains(String(characters[j])) {
                    leftConsonantFound = true
                    break
                }
            }
            
            for j in stride(from: i + 1, through: characters.count - 1, by: 1) {
                if !vowels.contains(String(characters[j])) {
                    rightConsonantFound = true
                    break
                }
            }
            
            if leftConsonantFound && rightConsonantFound {
                return String(characters[i])
            }
        }
    }
    
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var closestVowel: String?
    for i in 0..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(char) {
            closestVowel = char
            break
        } else if consonants.contains(char) {
            if let closestVowel = closestVowel {
                return closestVowel
            }
        }
    }
    return closestVowel ?? ""
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == "" [/INST] ```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var closestVowel: String?
    for i in 0..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(char) {
            closestVowel = char
            break
        } else if consonants.contains(char) {
            if let closestVowel = closestVowel {
                return closestVowel
            }
        }
    }
    return closestVowel ?? ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    for i in 0..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(char) {
            closestVowel = char
            break
        }
    }
    return closestVowel
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == "" [/INST] ```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    for i in 0..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(char) {
            closestVowel = char
            break
        }
    }
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var closestVowel = ""
    for i in 0..<word.count {
        if vowels.contains(word[i]) {
            closestVowel = word[i]
            break
        } else if consonants.contains(word[i]) {
            if i < word.count - 1 && vowels.contains(word[i + 1]) {
                closestVowel = word[i + 1]
                break
            }
        }
    }
    return closestVowel
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == "" [/INST] ```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var closestVowel = ""
    for i in 0..<word.count {
        if vowels.contains(word[i]) {
            closestVowel = word[i]
            break
        } else if consonants.contains(word[i]) {
            if i < word.count - 1 && vowels.contains(word[i + 1]) {
                closestVowel = word[i + 1]
                break
            }
        }
    }
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel: String?
    for i in 0..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(char) {
            closestVowel = char
            break
        }
    }
    return closestVowel ?? ""
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == "" [/INST] ```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel: String?
    for i in 0..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(char) {
            closestVowel = char
            break
        }
    }
    return closestVowel ?? ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var closestVowel = ""
    for i in 0..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(char) {
            closestVowel = char
            break
        } else if consonants.contains(char) {
            if i > 0 {
                let previousChar = word[word.index(word.startIndex, offsetBy: i - 1)]
                if vowels.contains(previousChar) {
                    closestVowel = previousChar
                    break
                }
            }
            if i < word.count - 1 {
                let nextChar = word[word.index(word.startIndex, offsetBy: i + 1)]
                if vowels.contains(nextChar) {
                    closestVowel = nextChar
                    break
                }
            }
        }
    }
    return closestVowel
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == "" [/INST] ```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var closestVowel = ""
    for i in 0..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(char) {
            closestVowel = char
            break
        } else if consonants.contains(char) {
            if i > 0 {
                let previousChar = word[word.index(word.startIndex, offsetBy: i - 1)]
                if vowels.contains(previousChar) {
                    closestVowel = previousChar
                    break
                }
            }
            if i < word.count - 1 {
                let nextChar = word[word.index(word.startIndex, offsetBy: i + 1)]
                if vowels.contains(nextChar) {
                    closestVowel = nextChar
                    break
                }
            }
        }
    }
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var closestVowel = ""
    var foundVowel = false

    for i in 0..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(char) {
            closestVowel = char
            foundVowel = true
            break
        } else if consonants.contains(char) {
            if i > 0 && vowels.contains(word[word.index(word.startIndex, offsetBy: i - 1)]) {
                closestVowel = word[word.index(word.startIndex, offsetBy: i - 1)]
                foundVowel = true
                break
            }
        }
    }

    return foundVowel ? closestVowel : ""
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == "" [/INST] ```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var closestVowel = ""
    var foundVowel = false

    for i in 0..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(char) {
            closestVowel = char
            foundVowel = true
            break
        } else if consonants.contains(char) {
            if i > 0 && vowels.contains(word[word.index(word.startIndex, offsetBy: i - 1)]) {
                closestVowel = word[word.index(word.startIndex, offsetBy: i - 1)]
                foundVowel = true
                break
            }
        }
    }

    return foundVowel ? closestVowel : ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var closestVowel = ""
    var foundVowel = false
    for i in 0..<word.count {
        if consonants.contains(word[word.index(word.startIndex, offsetBy: i)]) {
            if foundVowel {
                closestVowel = word[word.index(word.startIndex, offsetBy: i - 1)]
                break
            }
        } else if vowels.contains(word[word.index(word.startIndex, offsetBy: i)]) {
            foundVowel = true
        }
    }
    return closestVowel
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == "" [/INST] ```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var closestVowel = ""
    var foundVowel = false
    for i in 0..<word.count {
        if consonants.contains(word[word.index(word.startIndex, offsetBy: i)]) {
            if foundVowel {
                closestVowel = word[word.index(word.startIndex, offsetBy: i - 1)]
                break
            }
        } else if vowels.contains(word[word.index(word.startIndex, offsetBy: i)]) {
            foundVowel = true
        }
    }
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var closestVowel = ""
    var foundVowel = false
    for i in 0..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(char) {
            closestVowel = char
            foundVowel = true
            break
        } else if consonants.contains(char) {
            if i < word.count - 1 {
                let nextChar = word[word.index(word.startIndex, offsetBy: i + 1)]
                if vowels.contains(nextChar) {
                    closestVowel = nextChar
                    foundVowel = true
                    break
                }
            }
        }
    }
    return foundVowel ? closestVowel : ""
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == "" [/INST] ```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var closestVowel = ""
    var foundVowel = false
    for i in 0..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(char) {
            closestVowel = char
            foundVowel = true
            break
        } else if consonants.contains(char) {
            if i < word.count - 1 {
                let nextChar = word[word.index(word.startIndex, offsetBy: i + 1)]
                if vowels.contains(nextChar) {
                    closestVowel = nextChar
                    foundVowel = true
                    break
                }
            }
        }
    }
    return foundVowel ? closestVowel : ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var closestVowel: String?
    for i in 0..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(char) {
            closestVowel = char
            break
        }
        if consonants.contains(char) {
            if let nextChar = word[word.index(word.startIndex, offsetBy: i + 1)], vowels.contains(nextChar) {
                closestVowel = nextChar
                break
            }
        }
    }
    return closestVowel ?? ""
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == "" [/INST] ```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var closestVowel: String?
    for i in 0..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(char) {
            closestVowel = char
            break
        }
        if consonants.contains(char) {
            if let nextChar = word[word.index(word.startIndex, offsetBy: i + 1)], vowels.contains(nextChar) {
                closestVowel = nextChar
                break
            }
        }
    }
    return closestVowel ?? ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var closestVowel = ""
    for i in 0..<word.count {
        if consonants.contains(word[word.index(word.startIndex, offsetBy: i)]) {
            if i + 1 < word.count && vowels.contains(word[word.index(word.startIndex, offsetBy: i + 1)]) {
                closestVowel = word[word.index(word.startIndex, offsetBy: i + 1)]
                break
            }
        }
    }
    return closestVowel
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == "" [/INST] ```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    var closestVowel = ""
    for i in 0..<word.count {
        if consonants.contains(word[word.index(word.startIndex, offsetBy: i)]) {
            if i + 1 < word.count && vowels.contains(word[word.index(word.startIndex, offsetBy: i + 1)]) {
                closestVowel = word[word.index(word.startIndex, offsetBy: i + 1)]
                break
            }
        }
    }
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    
    var closestVowel = ""
    var lastConsonant = ""
    
    for char in word {
        if consonants.contains(char) {
            lastConsonant = char
        } else if vowels.contains(char) {
            if lastConsonant != "" {
                closestVowel = char
                break
            }
        }
    }
    
    return closestVowel
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == "" [/INST] ```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    
    var closestVowel = ""
    var lastConsonant = ""
    
    for char in word {
        if consonants.contains(char) {
            lastConsonant = char
        } else if vowels.contains(char) {
            if lastConsonant != "" {
                closestVowel = char
                break
            }
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    let consonants = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
    
    guard word.count > 2 else { return "" }
    
    var closestVowel = ""
    var lastConsonant = ""
    
    for i in (1..<word.count - 1).reversed() {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if consonants.contains(char) {
            lastConsonant = char
            break
        }
    }
    
    for i in (1..<word.count - 1) {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(char) {
            closestVowel = char
            break
        }
    }
    
    if closestVowel.isEmpty {
        return ""
    }
    
    if lastConsonant.isEmpty {
        return closestVowel
    }
    
    let lastConsonantIndex = word.lastIndex(of: lastConsonant)!
    let closestVowelIndex = word.firstIndex(of: closestVowel)!
    
    if lastConsonantIndex < closestVowelIndex {
        return ""
    }
    
    return closestVowel
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == "" [/INST] ```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    let consonants = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
    
    guard word.count > 2 else { return "" }
    
    var closestVowel = ""
    var lastConsonant = ""
    
    for i in (1..<word.count - 1).reversed() {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if consonants.contains(char) {
            lastConsonant = char
            break
        }
    }
    
    for i in (1..<word.count - 1) {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(char) {
            closestVowel = char
            break
        }
    }
    
    if closestVowel.isEmpty {
        return ""
    }
    
    if lastConsonant.isEmpty {
        return closestVowel
    }
    
    let lastConsonantIndex = word.lastIndex(of: lastConsonant)!
    let closestVowelIndex = word.firstIndex(of: closestVowel)!
    
    if lastConsonantIndex < closestVowelIndex {
        return ""
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    
    var closestVowel = ""
    var lastConsonant = ""
    
    for i in (0..<word.count).reversed() {
        let char = word[i]
        if consonants.contains(char) {
            lastConsonant = char
        } else if vowels.contains(char) {
            if lastConsonant != "" {
                closestVowel = char
                break
            }
        }
    }
    
    return closestVowel
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == "" [/INST] ```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    
    var closestVowel = ""
    var lastConsonant = ""
    
    for i in (0..<word.count).reversed() {
        let char = word[i]
        if consonants.contains(char) {
            lastConsonant = char
        } else if vowels.contains(char) {
            if lastConsonant != "" {
                closestVowel = char
                break
            }
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var previousConsonant = ""
    var currentConsonant = ""
    var nextConsonant = ""
    
    for (index, character) in word.enumerated() {
        if index == 0 {
            previousConsonant = ""
        } else {
            previousConsonant = word[index - 1]
        }
        currentConsonant = character
        if index == word.count - 1 {
            nextConsonant = ""
        } else {
            nextConsonant = word[index + 1]
        }
        
        if vowels.contains(currentConsonant) && previousConsonant.isConsonant && nextConsonant.isConsonant {
            closestVowel = currentConsonant
            break
        }
    }
    
    return closestVowel
}

extension Character {
    var isConsonant: Bool {
        return !isVowel
    }
    
    var isVowel: Bool {
        return ["a", "e", "i", "o", "u"].contains(self)
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == "" [/INST] ```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var previousConsonant = ""
    var currentConsonant = ""
    var nextConsonant = ""
    
    for (index, character) in word.enumerated() {
        if index == 0 {
            previousConsonant = ""
        } else {
            previousConsonant = word[index - 1]
        }
        currentConsonant = character
        if index == word.count - 1 {
            nextConsonant = ""
        } else {
            nextConsonant = word[index + 1]
        }
        
        if vowels.contains(currentConsonant) && previousConsonant.isConsonant && nextConsonant.isConsonant {
            closestVowel = currentConsonant
            break
        }
    }
    
    return closestVowel
}

extension Character {
    var isConsonant: Bool {
        return !isVowel
    }
    
    var isVowel: Bool {
        return ["a", "e", "i", "o", "u"].contains(self)
    }
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    
    var closestVowel = ""
    var lastConsonant = ""
    
    for i in 0..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if consonants.contains(char) {
            lastConsonant = char
        } else if vowels.contains(char) {
            if lastConsonant != "" {
                closestVowel = char
                break
            }
        }
    }
    
    return closestVowel
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == "" [/INST] ```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    
    var closestVowel = ""
    var lastConsonant = ""
    
    for i in 0..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if consonants.contains(char) {
            lastConsonant = char
        } else if vowels.contains(char) {
            if lastConsonant != "" {
                closestVowel = char
                break
            }
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""

    for i in (1...word.count - 1).reversed() {
        let char = word[word.index(word.endIndex, offsetBy: -i)]
        if vowels.contains(char) {
            closestVowel = char
            break
        }
    }

    return closestVowel
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == "" [/INST] ```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""

    for i in (1...word.count - 1).reversed() {
        let char = word[word.index(word.endIndex, offsetBy: -i)]
        if vowels.contains(char) {
            closestVowel = char
            break
        }
    }

    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""

    for i in 1..<word.count {
        let char = word[word.index(word.endIndex, offsetBy: -i)]
        if vowels.contains(char) {
            closestVowel = char
            break
        }
    }

    return closestVowel
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == "" [/INST] ```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""

    for i in 1..<word.count {
        let char = word[word.index(word.endIndex, offsetBy: -i)]
        if vowels.contains(char) {
            closestVowel = char
            break
        }
    }

    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    for i in (1...word.count-1).reversed() {
        if vowels.contains(word[i]) {
            closestVowel = word[i]
            break
        }
    }
    return closestVowel
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == "" [/INST] ```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    for i in (1...word.count-1).reversed() {
        if vowels.contains(word[i]) {
            closestVowel = word[i]
            break
        }
    }
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    for i in 1..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(char) {
            closestVowel = char
            break
        }
    }
    return closestVowel
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == "" [/INST] ```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    for i in 1..<word.count {
        let char = word[word.index(word.startIndex, offsetBy: i)]
        if vowels.contains(char) {
            closestVowel = char
            break
        }
    }
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    
    var closestVowel = ""
    var lastConsonant = ""
    
    for i in (0..<word.count) {
        let char = word[i]
        if consonants.contains(char) {
            lastConsonant = char
        } else if vowels.contains(char) {
            if lastConsonant != "" {
                closestVowel = char
                break
            }
        }
    }
    
    return closestVowel
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == "" [/INST] ```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let consonants = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
    
    var closestVowel = ""
    var lastConsonant = ""
    
    for i in (0..<word.count) {
        let char = word[i]
        if consonants.contains(char) {
            lastConsonant = char
        } else if vowels.contains(char) {
            if lastConsonant != "" {
                closestVowel = char
                break
            }
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let reversedWord = word.reversed()
    for (i, char) in reversedWord.enumerated() {
        if vowels.contains(char) && i > 0 && i < reversedWord.count - 1 {
            return String(char)
        }
    }
    return ""
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == "" [/INST] ```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let reversedWord = word.reversed()
    for (i, char) in reversedWord.enumerated() {
        if vowels.contains(char) && i > 0 && i < reversedWord.count - 1 {
            return String(char)
        }
    }
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var foundVowel = false

    for i in (0..<word.count).reversed() {
        let char = word[i]
        if vowels.contains(char) {
            closestVowel = char
            foundVowel = true
            break
        }
    }

    if foundVowel {
        return closestVowel
    } else {
        return ""
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == "" [/INST] ```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var foundVowel = false

    for i in (0..<word.count).reversed() {
        let char = word[i]
        if vowels.contains(char) {
            closestVowel = char
            foundVowel = true
            break
        }
    }

    if foundVowel {
        return closestVowel
    } else {
        return ""
    }
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let reversedWord = word.reversed()
    for (index, char) in reversedWord.enumerated() {
        if vowels.contains(char) && index > 0 && index < reversedWord.count - 1 {
            return String(char)
        }
    }
    return ""
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == "" [/INST] ```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let reversedWord = word.reversed()
    for (index, char) in reversedWord.enumerated() {
        if vowels.contains(char) && index > 0 && index < reversedWord.count - 1 {
            return String(char)
        }
    }
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var foundVowel = false

    for i in (0..<word.count).reversed() {
        if vowels.contains(word[i]) {
            closestVowel = word[i]
            foundVowel = true
            break
        }
    }

    if foundVowel {
        return closestVowel
    } else {
        return ""
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == "" [/INST] ```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var foundVowel = false

    for i in (0..<word.count).reversed() {
        if vowels.contains(word[i]) {
            closestVowel = word[i]
            foundVowel = true
            break
        }
    }

    if foundVowel {
        return closestVowel
    } else {
        return ""
    }
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var foundVowel = false

    for i in (0..<word.count).reversed() {
        let char = word[i]
        if vowels.contains(char) {
            closestVowel = char
            foundVowel = true
            break
        }
    }

    if foundVowel {
        return closestVowel
    } else {
        return ""
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == "" [/INST] ```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var foundVowel = false

    for i in (0..<word.count).reversed() {
        let char = word[i]
        if vowels.contains(char) {
            closestVowel = char
            foundVowel = true
            break
        }
    }

    if foundVowel {
        return closestVowel
    } else {
        return ""
    }
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var foundVowel = false

    for i in (0..<word.count).reversed() {
        let char = word[i]
        if vowels.contains(char) {
            foundVowel = true
            closestVowel = char
            break
        }
    }

    if foundVowel {
        return closestVowel
    } else {
        return ""
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == "" [/INST] ```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var foundVowel = false

    for i in (0..<word.count).reversed() {
        let char = word[i]
        if vowels.contains(char) {
            foundVowel = true
            closestVowel = char
            break
        }
    }

    if foundVowel {
        return closestVowel
    } else {
        return ""
    }
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let reversedWord = word.reversed()
    var closestVowel = ""

    for (index, character) in reversedWord.enumerated() {
        if vowels.contains(character) {
            closestVowel = String(character)
            break
        }

        if index == reversedWord.count - 1 {
            return ""
        }
    }

    return closestVowel
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == "" [/INST] ```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let reversedWord = word.reversed()
    var closestVowel = ""

    for (index, character) in reversedWord.enumerated() {
        if vowels.contains(character) {
            closestVowel = String(character)
            break
        }

        if index == reversedWord.count - 1 {
            return ""
        }
    }

    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var foundVowel = false

    for i in (0..<word.count).reversed() {
        let char = String(word[i])
        if vowels.contains(char) {
            closestVowel = char
            foundVowel = true
            break
        }
    }

    if foundVowel {
        return closestVowel
    } else {
        return ""
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == "" [/INST] ```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var foundVowel = false

    for i in (0..<word.count).reversed() {
        let char = String(word[i])
        if vowels.contains(char) {
            closestVowel = char
            foundVowel = true
            break
        }
    }

    if foundVowel {
        return closestVowel
    } else {
        return ""
    }
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var foundVowel = false

    for i in (0..<word.count).reversed() {
        let char = word[i]
        if vowels.contains(char) {
            closestVowel = char
            foundVowel = true
            break
        }
    }

    if foundVowel {
        return closestVowel
    } else {
        return ""
    }
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == "" [/INST] ```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var foundVowel = false

    for i in (0..<word.count).reversed() {
        let char = word[i]
        if vowels.contains(char) {
            closestVowel = char
            foundVowel = true
            break
        }
    }

    if foundVowel {
        return closestVowel
    } else {
        return ""
    }
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let reversedWord = String(word.reversed())
    for i in 0..<reversedWord.count-1 {
        if vowels.contains(reversedWord[i]) && !vowels.contains(reversedWord[i+1]) {
            return String(reversedWord[i])
        }
    }
    return ""
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == "" [/INST] ```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    let reversedWord = String(word.reversed())
    for i in 0..<reversedWord.count-1 {
        if vowels.contains(reversedWord[i]) && !vowels.contains(reversedWord[i+1]) {
            return String(reversedWord[i])
        }
    }
    return ""
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var leftIndex = 0
    var rightIndex = word.count - 1
    
    while leftIndex < rightIndex {
        let leftChar = word[leftIndex]
        let rightChar = word[rightIndex]
        
        if vowels.contains(String(leftChar).lowercased()) {
            result = String(leftChar).lowercased()
            break
        }
        
        if vowels.contains(String(rightChar).lowercased()) {
            result = String(rightChar).lowercased()
            break
        }
        
        if!vowels.contains(String(leftChar).lowercased()) &&!vowels.contains(String(rightChar).lowercased()) {
            leftIndex += 1
            rightIndex -= 1
        } else {
            break
        }
    }
    
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var leftIndex = 0
    var rightIndex = word.count - 1
    
    while leftIndex < rightIndex {
        let leftChar = word[leftIndex]
        let rightChar = word[rightIndex]
        
        if vowels.contains(String(leftChar).lowercased()) {
            result = String(leftChar).lowercased()
            break
        }
        
        if vowels.contains(String(rightChar).lowercased()) {
            result = String(rightChar).lowercased()
            break
        }
        
        if!vowels.contains(String(leftChar).lowercased()) &&!vowels.contains(String(rightChar).lowercased()) {
            leftIndex += 1
            rightIndex -= 1
        } else {
            break
        }
    }
    
    return result
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var leftIndex = 0
    var rightIndex = word.count - 1
    
    while leftIndex < rightIndex {
        if vowels.contains(String(word[leftIndex])) {
            result = String(word[leftIndex])
            break
        }
        if vowels.contains(String(word[rightIndex])) {
            result = String(word[rightIndex])
            break
        }
        leftIndex += 1
        rightIndex -= 1
    }
    
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var leftIndex = 0
    var rightIndex = word.count - 1
    
    while leftIndex < rightIndex {
        if vowels.contains(String(word[leftIndex])) {
            result = String(word[leftIndex])
            break
        }
        if vowels.contains(String(word[rightIndex])) {
            result = String(word[rightIndex])
            break
        }
        leftIndex += 1
        rightIndex -= 1
    }
    
    return result
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var leftIndex = 0
    var rightIndex = word.count - 1
    
    while leftIndex < rightIndex {
        if vowels.contains(String(word[leftIndex])) {
            result = String(word[leftIndex])
            break
        }
        if vowels.contains(String(word[rightIndex])) {
            result = String(word[rightIndex])
            break
        }
        leftIndex += 1
        rightIndex -= 1
    }
    
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var leftIndex = 0
    var rightIndex = word.count - 1
    
    while leftIndex < rightIndex {
        if vowels.contains(String(word[leftIndex])) {
            result = String(word[leftIndex])
            break
        }
        if vowels.contains(String(word[rightIndex])) {
            result = String(word[rightIndex])
            break
        }
        leftIndex += 1
        rightIndex -= 1
    }
    
    return result
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var left = 0
    var right = word.count - 1
    
    while left < right {
        if vowels.contains(String(word[left])) {
            result = String(word[left])
            break
        }
        if vowels.contains(String(word[right])) {
            result = String(word[right])
            break
        }
        left += 1
        right -= 1
    }
    
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var left = 0
    var right = word.count - 1
    
    while left < right {
        if vowels.contains(String(word[left])) {
            result = String(word[left])
            break
        }
        if vowels.contains(String(word[right])) {
            result = String(word[right])
            break
        }
        left += 1
        right -= 1
    }
    
    return result
}
```

func getClosestVowel(word: String) -> String {
    guard let first = word.first, let last = word.last else { return "" }
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel: String?
    var closestDistance: Int?

    for (index, char) in word.enumerated() {
        if!vowels.contains(String(char).lowercased()) { continue }

        let distance = abs(first.asciiValue! - char.asciiValue!)
        if let currentDistance = closestDistance, currentDistance > distance {
            continue
        }

        closestVowel = String(char)
        closestDistance = distance
    }

    return closestVowel?? ""
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    guard let first = word.first, let last = word.last else { return "" }
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel: String?
    var closestDistance: Int?

    for (index, char) in word.enumerated() {
        if!vowels.contains(String(char).lowercased()) { continue }

        let distance = abs(first.asciiValue! - char.asciiValue!)
        if let currentDistance = closestDistance, currentDistance > distance {
            continue
        }

        closestVowel = String(char)
        closestDistance = distance
    }

    return closestVowel?? ""
}
```

func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var index = 0
    var lastVowelIndex = -1
    var lastConsonantIndex = -1
    
    for char in word.reversed() {
        if vowels.contains(String(char)) {
            index += 1
            if lastVowelIndex == -1 {
                lastVowelIndex = index
            } else {
                lastConsonantIndex = index
            }
        }
    }
    
    if lastVowelIndex > 0 && lastConsonantIndex > 0 {
        let vowelDistance = lastVowelIndex - lastConsonantIndex
        if vowelDistance > 1 {
            result = String(word[lastVowelIndex - 1])
        }
    }
    
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var index = 0
    var lastVowelIndex = -1
    var lastConsonantIndex = -1
    
    for char in word.reversed() {
        if vowels.contains(String(char)) {
            index += 1
            if lastVowelIndex == -1 {
                lastVowelIndex = index
            } else {
                lastConsonantIndex = index
            }
        }
    }
    
    if lastVowelIndex > 0 && lastConsonantIndex > 0 {
        let vowelDistance = lastVowelIndex - lastConsonantIndex
        if vowelDistance > 1 {
            result = String(word[lastVowelIndex - 1])
        }
    }
    
    return result
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var leftIndex = 0
    var rightIndex = word.count - 1
    
    while leftIndex < rightIndex {
        if vowels.contains(String(word[leftIndex])) {
            result = String(word[leftIndex])
            break
        }
        if vowels.contains(String(word[rightIndex])) {
            result = String(word[rightIndex])
            break
        }
        leftIndex += 1
        rightIndex -= 1
    }
    
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var leftIndex = 0
    var rightIndex = word.count - 1
    
    while leftIndex < rightIndex {
        if vowels.contains(String(word[leftIndex])) {
            result = String(word[leftIndex])
            break
        }
        if vowels.contains(String(word[rightIndex])) {
            result = String(word[rightIndex])
            break
        }
        leftIndex += 1
        rightIndex -= 1
    }
    
    return result
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var isVowel = false
    var isConsonant = false
    var isFirst = true
    var isLast = true
    var previousChar = ""
    
    for char in word {
        if vowels.contains(String(char).lowercased()) {
            isVowel = true
            isConsonant = false
            closestVowel = char
        } else if!vowels.contains(String(char).lowercased()) {
            isVowel = false
            isConsonant = true
            closestVowel = char
        }
        
        if isVowel && isConsonant {
            if isFirst {
                isFirst = false
                continue
            } else if isLast {
                isLast = false
                continue
            } else {
                return closestVowel
            }
        }
        
        if isVowel {
            isFirst = false
        } else if isConsonant {
            isLast = false
        }
        
        previousChar = char
    }
    
    return closestVowel
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var isVowel = false
    var isConsonant = false
    var isFirst = true
    var isLast = true
    var previousChar = ""
    
    for char in word {
        if vowels.contains(String(char).lowercased()) {
            isVowel = true
            isConsonant = false
            closestVowel = char
        } else if!vowels.contains(String(char).lowercased()) {
            isVowel = false
            isConsonant = true
            closestVowel = char
        }
        
        if isVowel && isConsonant {
            if isFirst {
                isFirst = false
                continue
            } else if isLast {
                isLast = false
                continue
            } else {
                return closestVowel
            }
        }
        
        if isVowel {
            isFirst = false
        } else if isConsonant {
            isLast = false
        }
        
        previousChar = char
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var leftIndex = 0
    var rightIndex = word.count - 1
    
    while leftIndex < rightIndex {
        if vowels.contains(String(word[leftIndex])) {
            result = String(word[leftIndex])
            break
        }
        if vowels.contains(String(word[rightIndex])) {
            result = String(word[rightIndex])
            break
        }
        leftIndex += 1
        rightIndex -= 1
    }
    
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var leftIndex = 0
    var rightIndex = word.count - 1
    
    while leftIndex < rightIndex {
        if vowels.contains(String(word[leftIndex])) {
            result = String(word[leftIndex])
            break
        }
        if vowels.contains(String(word[rightIndex])) {
            result = String(word[rightIndex])
            break
        }
        leftIndex += 1
        rightIndex -= 1
    }
    
    return result
}
```

func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var consonants = [Character]()
    
    for char in word {
        if vowels.contains(String(char)) {
            if consonants.count > 0 {
                let diff = abs(Int(String(char))?.distance(to: Int(String(consonants.last!)))!)
                if diff < 2 {
                    result = String(char)
                    break
                }
            }
        } else {
            consonants.append(char)
        }
    }
    
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    var vowels = ["a", "e", "i", "o", "u"]
    var result = ""
    var consonants = [Character]()
    
    for char in word {
        if vowels.contains(String(char)) {
            if consonants.count > 0 {
                let diff = abs(Int(String(char))?.distance(to: Int(String(consonants.last!)))!)
                if diff < 2 {
                    result = String(char)
                    break
                }
            }
        } else {
            consonants.append(char)
        }
    }
    
    return result
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            foundVowel = true
            if lastConsonantIndex!= -1 {
                closestVowel = String(word[lastConsonantIndex + 1..< index])
                break
            }
        } else if foundVowel {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            foundVowel = true
            if lastConsonantIndex!= -1 {
                closestVowel = String(word[lastConsonantIndex + 1..< index])
                break
            }
        } else if foundVowel {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    
    for (index, char) in word.enumerated() {
        if vowels.contains(char) {
            foundVowel = true
            if index > 0 && word[index - 1]!= " " {
                closestVowel = String(char)
                break
            }
        }
    }
    
    return closestVowel
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    
    for (index, char) in word.enumerated() {
        if vowels.contains(char) {
            foundVowel = true
            if index > 0 && word[index - 1]!= " " {
                closestVowel = String(char)
                break
            }
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    var consonantsCount = 0
    
    for char in word.reversed() {
        if vowels.contains(char) {
            foundVowel = true
            closestVowel = String(char)
            break
        } else {
            consonantsCount += 1
        }
    }
    
    if foundVowel && consonantsCount >= 2 {
        return closestVowel
    } else {
        return ""
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    var consonantsCount = 0
    
    for char in word.reversed() {
        if vowels.contains(char) {
            foundVowel = true
            closestVowel = String(char)
            break
        } else {
            consonantsCount += 1
        }
    }
    
    if foundVowel && consonantsCount >= 2 {
        return closestVowel
    } else {
        return ""
    }
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    var consonantsCount = 0
    
    for char in word.reversed() {
        if vowels.contains(char) {
            foundVowel = true
            closestVowel = String(char)
            break
        } else if!foundVowel {
            consonantsCount += 1
        }
    }
    
    if consonantsCount == word.count - 1 {
        return ""
    } else {
        return closestVowel
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    var consonantsCount = 0
    
    for char in word.reversed() {
        if vowels.contains(char) {
            foundVowel = true
            closestVowel = String(char)
            break
        } else if!foundVowel {
            consonantsCount += 1
        }
    }
    
    if consonantsCount == word.count - 1 {
        return ""
    } else {
        return closestVowel
    }
}
```

func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var foundVowel = false
    
    for char in word.reversed() {
        if vowels.contains(char.description.lowercased()) {
            closestVowel = char
            foundVowel = true
            break
        }
    }
    
    if foundVowel {
        return closestVowel
    } else {
        return ""
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = ["a", "e", "i", "o", "u"]
    var closestVowel = ""
    var foundVowel = false
    
    for char in word.reversed() {
        if vowels.contains(char.description.lowercased()) {
            closestVowel = char
            foundVowel = true
            break
        }
    }
    
    if foundVowel {
        return closestVowel
    } else {
        return ""
    }
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            foundVowel = true
            if lastConsonantIndex!= -1 {
                closestVowel = String(word[lastConsonantIndex + 1..<index])
                break
            }
        } else if foundVowel {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            foundVowel = true
            if lastConsonantIndex!= -1 {
                closestVowel = String(word[lastConsonantIndex + 1..<index])
                break
            }
        } else if foundVowel {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    
    for char in word.reversed() {
        if vowels.contains(char) {
            closestVowel = String(char)
            foundVowel = true
            break
        }
    }
    
    if foundVowel {
        return closestVowel
    } else {
        return ""
    }
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    
    for char in word.reversed() {
        if vowels.contains(char) {
            closestVowel = String(char)
            foundVowel = true
            break
        }
    }
    
    if foundVowel {
        return closestVowel
    } else {
        return ""
    }
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            foundVowel = true
            if lastConsonantIndex!= -1 {
                closestVowel = String(word[lastConsonantIndex + 1..< index])
                break
            }
        } else if foundVowel {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a word. Your task is to find the closest vowel that stands between 
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition. 
You may assume that the given string contains English letter only.
Example:
getClosestVowel(word: "yogurt") == "u"
getClosestVowel(word: "FULL") == "U"
getClosestVowel(word: "quick") == ""
getClosestVowel(word: "ab") == ""

Answer:
```swift
func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            foundVowel = true
            if lastConsonantIndex!= -1 {
                closestVowel = String(word[lastConsonantIndex + 1..< index])
                break
            }
        } else if foundVowel {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}
```

func getClosestVowel(word: String) -> String {
    let vowels = "aeiouAEIOU"
    var closestVowel = ""
    var foundVowel = false
    var lastConsonantIndex = -1
    
    for (index, character) in word.enumerated() {
        if vowels.contains(character) {
            foundVowel = true
            if lastConsonantIndex!= -1 {
                closestVowel = String(word[lastConsonantIndex + 1..<index])
                break
            }
        } else if foundVowel {
            lastConsonantIndex = index
        }
    }
    
    return closestVowel
}