方法一

思路：使用一个map，key为字符，val为对应的行号

  1. func findWords(words []string) []string {
  2.     hmap := map[byte]int{
  3.         'A': 1,
  4.         'B': 2,
  5.         'C': 2,
  6.         'D': 1,
  7.         'E': 0,
  8.         'F': 1,
  9.         'G': 1,
  10.         'H': 1,
  11.         'I': 0,
  12.         'J': 1,
  13.         'K': 1,
  14.         'L': 1,
  15.         'M': 2,
  16.         'N': 2,
  17.         'O': 0,
  18.         'P': 0,
  19.         'Q': 0,
  20.         'R': 0,
  21.         'S': 1,
  22.         'T': 0,
  23.         'U': 0,
  24.         'V': 2,
  25.         'W': 0,
  26.         'X': 2,
  27.         'Y': 0,
  28.         'Z': 2,
  29.     }
  31.     var flag bool
  33.     ret := []string{}
  35.     for _, word := range words {
  37.         start := hmap[byte(unicode.ToUpper(rune(word[0])))]
  38.         flag = true
  39.         for _, ch := range word {
  40.             if start != hmap[byte(unicode.ToUpper(ch))] {
  41.                 flag = false
  42.                 break
  43.             }
  44.         }
  46.         if flag {
  47.             ret = append(ret, word)
  48.         }
  49.     }
  50.     for _,v := range hmap {
  51.         fmt.Printf("%d", v)
  52.     }
  54.     return ret
  55. }

【推荐】方法二

思路：使用一个数组存储每一个字母的行号，不需要使用hmap
�

func findWords(words []string) []string {
    //二十六个字母在的行号
    rowLines := "12210111011122000010020202"

    var flag bool

    ret := []string{}

    for _, word := range words {

        start := rowLines[unicode.ToUpper(rune(word[0])) - 'A']
        flag = true
        for _, ch := range word {
            if start != rowLines[unicode.ToUpper(ch) - 'A'] {
                flag = false
                break
            }
        }

        if flag {
            ret = append(ret, word)
        }
    }

    return ret
}