用GO语言愉悦的刷LeetCode(算法题)

用GO语言快乐的刷LeetCode(算法题)

1.给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。
说明：本题中，我们将空字符串定义为有效的回文串。

package main
import (
	"fmt"
	"regexp"
	"strings"
)
//输入: "A man, a plan, a canal: Panama"
//输出: true
func main() {
	fmt.Println(isPalindromeString（"race a car"）)
}

func isPalindromeString(s string)bool{
	compile := regexp.MustCompile(`[\w]+`) //判断正则规范否
	findstring := compile.FindAllString(s,-1)//取得所有符合正则的字段 返回[]string{}
	a := strings.ToUpper(strings.TrimSpace(strings.Join(findstring,"")))//将取得的值整合成大写
	return isPalind(a)
}

//字段首尾比较
func isPalind(s string)bool{
	l,f := 0,len(s)-1
	for l < f{
       if s[l]==s[f]{
		   l++
		   f--
		   continue //相等跳过此循环
	   }
	   return false 
	}
	return true
}

2.给定一种规律 pattern 和一个字符串 str ，判断 str 是否遵循相同的规律
示例1:
输入: pattern = “abba”, str = “dog cat cat dog”
输出: true

package main

import (
	"fmt"
	"strings"
)

func main() {

	fmt.Println(wordPattern("abba","dog cat cat dog"))
}
func wordPattern(pattern string, str string) bool {
	pattmap := make(map[string]int) //初始化字典map
	patt := strings.Split(pattern,"")//“abba”字符串转为切片
	for i,v := range patt{  //循环“abba”切片
		if _,ok := pattmap[v];ok{
             pattmap[v] = pattmap[v] + i  // 将出现的所有下标值相加
		}else{
			pattmap[v] = i
		}
	}
	//所匹配的同理可得
	strmap := make(map[string]int)
	s := strings.Split(str," ")
	for i,v := range s{
		if _,ok := strmap[v];ok{
			strmap[v] = strmap[v] + i
		}else{
			strmap[v] = i
		}
	}
//比较下标值总和以及切片长度是否完全相同，是为true 否为false
	var n1,n2 int
	for _,v := range pattmap{
		n1 += v
	}
	for _,v := range strmap{
		n2 += v
	}

	return n1==n2&&len(patt)==len(s)
}

3.整数反转
例子： 123 > 321
package main

func main() {

fmt.Println(reserve(123))

}

func reserve(i int) int{
var sum int
for i != 0{
sum = sum * 10 + i % 10 //%取余数 123%10 = 3
i /= 10 //123/10 = 12(int整数类型 自动忽视小数点)
}
if sum > math.MaxInt32 || sum < math.MinInt32{
return 0
}
return sum
}

4.大写转小写的go语言实现
例子：“HHH” > “hhh”

package main

func main() {

	fmt.Println(toLowerCase("HHHHH"))
} 
func toLowerCase(str string) string {
	bytes := []byte(str)
	for i,v := range bytes{
         if v >='A'&& v<='Z'{
			 bytes[i] += 'a' - 'A'
		 }
	}
	return string(bytes)
}

5.归并排序

package main
import "fmt"


func  main()  {    
arr := []int{1,3,2,8,4,7}    
result := mergeSort(arr)    
fmt.Println(result)
}

func mergeSort(arr []int) []int  {    
if len(arr) <2 {        
return arr    
}    
i:=len(arr)/2   //对等分，i向下取整
l := mergeSort(arr[0:i])    
r:= mergeSort(arr[i:])    
result := merge(l,r)    
return result
}

func  merge(l,r []int) []int {    
a,b := 0,0    
c:=len(l)    
d:=len(r)    
result := make([]int,0)    
for a<c&&b<d{        
if l[a] > r[b]{           
result = append(result,r[b])           
b++           
continue        
}        
result = append(result,l[/a])        
a++    
}    
result = append(result,r[b:]...)    //...语法糖，合并数组或切片使用
result = append(result,l[a:]...)    
return result    
}