字符匹配Boyer-Moore算法，go實現

參考：https://blog.csdn.net/qpzkobe/article/details/80716922
func TestBoyerMooer() {
   text := "helloword"
   patten := "ellowor"
   left, right := BoyerMooer(text, patten)
   right++
   fmt.Println(text[left:right])
   if text[left:right] == patten {
      fmt.Println("success")
   } else {
      fmt.Println("err")
   }

}

/*
//壞字符--//匹配0個字符//匹配>0個字符
      //好後綴是否存在
      //好後綴存在patten前面部分中，對齊

      //不存在，尋找最長左前綴，對齊

      //不存在最長前綴，直接移動patten到好後綴的下一個字符
      //patten中有壞字符，對齊
      //patten中沒有壞字符，patten移動到壞字符的下一個字符
*/
func BoyerMooer(text, patten string) (int, int) {
   if len(text) < len(patten) {
      return 0, 0
   }

   p_len := len(patten) - 1
   t_tail := p_len
   p_tail := p_len

   var equal_continuous_str []uint8
   var equal_local []int

   for ; t_tail <= (len(text)-1) && p_tail >= 0; {
      tail_str := text[t_tail]
      patten_str := patten[p_tail]

      mach := tail_str == patten_str

      if mach {
         equal_continuous_str = append(equal_continuous_str, text[t_tail])
         equal_local = append(equal_local, t_tail)
         t_tail--
         p_tail--
      }

      if len(equal_continuous_str) == p_len+1 {
         return equal_local[len(equal_local)-1], equal_local[0]
      }

      if mach {
         continue
      }

      len_equal_continuous_str := len(equal_continuous_str)

      //bad str
      if !mach {

         //壞字符是否存在與patten
         bad_patten_ptr := p_tail
         for ; bad_patten_ptr >= 0; bad_patten_ptr-- {
            if patten[bad_patten_ptr] == tail_str {
               //對齊
               t_tail += (p_tail - bad_patten_ptr)
               p_tail = p_len
               equal_continuous_str = []uint8{}
               equal_local = []int{}
               break
            }
         }
         if bad_patten_ptr >= 0 {
            continue
         }

         t_tail += p_len + 1
         p_tail = p_len
         //clear
         equal_continuous_str = []uint8{}
         equal_local = []int{}
         continue
      }
      //好後綴
      if len_equal_continuous_str > 0 {
         //存在好後綴
         patten_ptr := p_tail
         var p_equal_local int
         for i := 0; patten_ptr >= 0; patten_ptr -- {
            if i == len_equal_continuous_str {
               //對齊
               t_tail += (p_tail - p_equal_local) + 1
               p_tail = p_len
               //clear
               equal_continuous_str = []uint8{}
               equal_local = []int{}
               continue
            }
            if patten[patten_ptr] == equal_continuous_str[i] {
               p_equal_local = patten_ptr
               i++
            } else {
               p_equal_local = 0
               i = 0
            }
         }
         //存在最長前綴
         var p_e_local_last int
         var p_e_local_tmp int
         var e_count int
         var e_count_tmp int
         pre_patten_ptr := p_tail

         for i := 0; p_tail >= 0; p_tail-- {

            if patten[pre_patten_ptr] == equal_continuous_str[i] {
               if i == 0 {
                  p_e_local_tmp = pre_patten_ptr
                  e_count_tmp ++
                  i++
               }
               e_count_tmp ++
               i++
            } else {
               p_e_local_last = p_e_local_tmp
               e_count = e_count_tmp
               i = 0
            }

            if e_count_tmp > e_count {
               p_e_local_last = p_e_local_tmp
               e_count = e_count_tmp
            }
         }
         if e_count > 0 {
            t_tail += p_tail - p_e_local_last + len_equal_continuous_str + 1
            p_tail = p_len
            equal_continuous_str = []uint8{}
            equal_local = []int{}
            continue
         }
         //不存在
         t_tail += len_equal_continuous_str + 1
         p_tail = p_len
         equal_continuous_str = []uint8{}
         equal_local = []int{}
         continue
      }
      //compare

   }
   return 0, 0
}