[Swift]LeetCode953. 验证外星语词典 | Verifying an Alien Dictionary

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/10090815.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

In an alien language, surprisingly they also use english lowercase letters, but possibly in a different order. The order of the alphabet is some permutation of lowercase letters.

Given a sequence of words written in the alien language, and the order of the alphabet, return true if and only if the given words are sorted lexicographicaly in this alien language.

Example 1:

Input: words = ["hello","leetcode"], order = "hlabcdefgijkmnopqrstuvwxyz"
Output: true
Explanation: As 'h' comes before 'l' in this language, then the sequence is sorted.

Example 2:

Input: words = ["word","world","row"], order = "worldabcefghijkmnpqstuvxyz"
Output: false
Explanation: As 'd' comes after 'l' in this language, then words[0] > words[1], hence the sequence is unsorted.

Example 3:

Input: words = ["apple","app"], order = "abcdefghijklmnopqrstuvwxyz"
Output: false
Explanation: The first three characters "app" match, and the second string is shorter (in size.) According to lexicographical rules "apple" > "app", because 'l' > '∅', where '∅' is defined as the blank character which is less than any other character (More info).

Note:

1. 1 <= words.length <= 100
2. 1 <= words[i].length <= 20
3. order.length == 26
4. All characters in words[i] and order are english lowercase letters.

---

某种外星语也使用英文小写字母，但可能顺序 order 不同。字母表的顺序（order）是一些小写字母的排列。

给定一组用外星语书写的单词 words，以及其字母表的顺序 order，只有当给定的单词在这种外星语中按字典序排列时，返回 true；否则，返回 false。

示例 1：

输入：words = ["hello","leetcode"], order = "hlabcdefgijkmnopqrstuvwxyz"
输出：true
解释：在该语言的字母表中，'h' 位于 'l' 之前，所以单词序列是按字典序排列的。

示例 2：

输入：words = ["word","world","row"], order = "worldabcefghijkmnpqstuvxyz"
输出：false
解释：在该语言的字母表中，'d' 位于 'l' 之后，那么 words[0] > words[1]，因此单词序列不是按字典序排列的。

示例 3：

输入：words = ["apple","app"], order = "abcdefghijklmnopqrstuvwxyz"
输出：false
解释：当前三个字符 "app" 匹配时，第二个字符串相对短一些，然后根据词典编纂规则 "apple" > "app"，因为 'l' > '∅'，其中 '∅' 是空白字符，定义为比任何其他字符都小（更多信息）。

提示：

1. 1 <= words.length <= 100
2. 1 <= words[i].length <= 20
3. order.length == 26
4. 在 words[i] 和 order 中的所有字符都是英文小写字母。

---

28ms

class Solution {
    func isAlienSorted(_ words: [String], _ order: String) -> Bool {
        var ret = true
        
        for i in 1 ..< words.count {
            ret = isInOrder(words[i-1], words[i], order)
            if !ret { return false }
        }
        
        return true
    }
    
    func isInOrder(_ word1: String, _ word2: String, _ order: String) -> Bool{
        
        let word1 = Array(word1)
        let word2 = Array(word2)
        
        var i = 0, j = 0
        while i < word1.count && j < word2.count {
            if order.firstIndex(of: word1[i])! == order.firstIndex(of: word2[j])! {
                i += 1
                j += 1
            }else if order.firstIndex(of: word1[i])! < order.firstIndex(of: word2[j])!{
                return true
            }else {
                return false
            }
        }
        
        if word1.count == word2.count {
            return true
        } else if word1.count > word2.count{
            return false
        }
        
        return true
    }
}

---

32ms

class Solution {
    private var map = [Character: Int]()
    func isAlienSorted(_ words: [String], _ order: String) -> Bool {
        for (index, char) in order.enumerated() {
            map[char] = index
        }
        
        for (index, word) in words.enumerated() where index < words.count-1 {
            if !wordsInOrder(word1: word, word2: words[index+1]) {
                return false
            }
        }
        
        return true
    }
    
    private func wordsInOrder(word1: String, word2: String) -> Bool {
        let one = Array(word1)
        let two = Array(word2)
        
        var index = 0
        var areEqual = true
        
        while index < one.count || index < two.count {
            if areEqual && two.count == index && one.count > index {
                return false
            } else if areEqual && one.count == index && two.count > index {
                return true
            } 
            
            let first = one[index]
            let second = two[index]
            
            index += 1
            
            if first == second {
                continue
            } else {
                areEqual = false
            }
            
            if map[first]! < map[second]! {
                return true
            } else if map[first]! == map[second]! {
                continue
            } else {
                return false
            }
        }
        
        return true
    }
}

---

40ms

class Solution {
  func isAlienSorted(_ words: [String], _ order: String) -> Bool {
    var dict: [Character: Int] = [:]
    
    for (i, char) in order.enumerated() {
      dict[char] = i
    }
    
    outer: for i in 0..<words.count - 1 {
      var j = 0
      let currWord = Array(words[i])
      let nextWord = Array(words[i + 1])
      
      while j < currWord.count && j < nextWord.count {
        let currVal = dict[currWord[j]]!
        let nextVal = dict[nextWord[j]]!
        if currVal > nextVal {
          return false
        } else if currVal < nextVal {
          continue outer
        }
        j += 1
      }
      
      return false
    }
    
    return true
  }
}

---

44ms

class Solution {
    
    var orderDic : [Character:Int] = [:]
    
    func isAlienSorted(_ words: [String], _ order: String) -> Bool {
        var currentOrder = 0
        for (idx,ord) in order.enumerated() {
            orderDic[ord] = idx
        }
        
        for i in 0..<words.count-1 {
            if !self.isOrdered(words[i], words[i+1]) {
                return false
            }
        }
        
        return true
    }
    
    func isOrdered(_ word1 : String, _ word2: String) -> Bool {
        let word2Chars = Array(word2)
        for (idx, char) in word1.enumerated() {
            if idx >= word2.count {
                return false
            }
            
            if orderDic[char]! > orderDic[word2Chars[idx]]! {
                return false
            } else if orderDic[char]! < orderDic[word2Chars[idx]]! {
                return true
            }
        }
        
        return true
    }
}

---

48ms

class Solution {
    func isAlienSorted(_ words: [String], _ order: String) -> Bool {

        var map = [Character: Int]()
        let orderChars = Array(order)
        for i in 0..<orderChars.count {
            map[orderChars[i]] = i
        }

        for i in 1..<words.count {
            if !isAscend(words[i-1], words[i], map: map) {
                return false
            }
        }
        return true
    }

    func isAscend(_ str1: String, _ str2: String, map:[Character: Int]) -> Bool {

        let char1 = Array(str1)
        let char2 = Array(str2)

        let len = min(char1.count, char2.count)

        for i in 0..<len {
            if map[char1[i]]! > map[char2[i]]!{
                return false
            }
            if map[char1[i]]! < map[char2[i]]!{
                return true
            }
        }
        return char1.count <= char2.count
    }
}

---

52ms

class Solution {
func isAlienSorted(_ words: [String], _ order: String) -> Bool {
    var index = 0
    var dict = [Character: Int]()
    for char in order {
        dict[char] = index
        index += 1
    }
    //
    if words.count == 1 {return true}
    var base = words[0]
    for i in 1..<words.count {
        var curIndex = words[i].startIndex
        while !base.isEmpty && base != words[i] {
            
            if dict[base.first!]! < dict[words[i][curIndex]]! {
                base = words[i]
                continue
            } else if dict[base.first!] == dict[words[i].first!] {
                base.removeFirst()
              if curIndex == words[i].index(words[i].startIndex, offsetBy: words[i].count - 1) && !base.isEmpty { return false }
               curIndex = words[i].index(after: curIndex) 
                
            } else {
                return false
            }
            
        }
    }
    return true
}
}

---

72ms

class Solution {
    func isAlienSorted(_ words: [String], _ order: String) -> Bool {
        var words = words
        var a:[Int] = [Int](repeating:0,count:256)
        var i:Int = 0
        var j:Int = 0
        for i in 0..<order.count
        {
            a[order[i].ascii] = i
        }
        for i in 0..<words.count
        {
            for j in 0..<words[i].count
            {
                //a:97
                words[i][j] = (a[words[i][j].ascii] + 97).ASCII
            }
        }
         for i in 0..<(words.count - 1)
        {
            if words[i] > words[i+1]
            {
                return false
            }
        }
        return true
    }
}
extension String {        
    //subscript函数可以检索数组中的值
    //直接按照索引方式截取指定索引的字符
    subscript (_ i: Int) -> Character {
        //读取字符
        get {return self[index(startIndex, offsetBy: i)]}
        
        //修改字符
        set
        {
            var str:String = self
            var index = str.index(startIndex, offsetBy: i)
            str.remove(at: index)
            str.insert(newValue, at: index)
            self = str
        }
    }
}

//Character扩展方法  
extension Character  
{  
  //属性：ASCII整数值(定义小写为整数值)
   var ascii: Int {
        get {
            let s = String(self).unicodeScalars
            return Int(s[s.startIndex].value)
        }
    }
}

//Int扩展方法  
extension Int
{
    //属性：ASCII值(定义大写为字符值)
    var ASCII:Character 
    {
        get {return Character(UnicodeScalar(self)!)}
    }
}