golang力扣刷题（一）

---

title: golang力扣刷题（一）
date: 2021-10-14 21:03:50
categories:

• go
  tags:
• 基础

---

力扣刷题（一）

力扣刷题 全部题目模块（1～30）

简单

山峰数组

符合下列属性的数组 arr 称为 山峰数组（山脉数组） ：arr.length >= 3存在 i（0 < i < arr.length - 1）使得：
arr[0] < arr[1] < … arr[i-1] < arr[i] arr[i] > arr[i+1] > … > arr[arr.length - 1] 给定由整数组成的山峰数组 arr ，返回任何满足 arr[0] < arr[1] < … arr[i - 1] < arr[i] > arr[i + 1] > … > arr[arr.length - 1] 的下标 i ，即山峰顶部。

示例 1：

输入：arr = [0,1,0]
输出：1

示例 2：

输入：arr = [1,3,5,4,2]
输出：2

func peakIndexInMountainArray(arr []int) int {
       var i,j int
       j=len(arr)-1
   for i=0;i<j;i++{
    if (arr[i]>arr[j]) {
         j=j-1
         i=i-1
    }
   }
   return i
}从
执行用时：8 ms, 在所有 Go 提交中击败了88.24%的用户
内存消耗：4.5 MB, 在所有 Go 提交中击败了16.18%的用户

两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：
输入：nums = [3,2,4], target = 6
输出：[1,2]

func twoSum(nums []int, target int) []int {
    var i,j int
    //b:=[]int{}  这里定义的切片已经被赋值，切片是只读对象
    b:=make([]int, 2)    //var b []int
    for i=0;i<len(nums)-1;i++{
        for j=i+1;j<=len(nums)-1;j++{
            if(nums[i]+nums[j]==target){            
              b[0]=i
              b[1]=j         
            }
        }
    }
    return b
}
执行用时：36 ms, 在所有 Go 提交中击败了9.31%的用户
内存消耗：3.7 MB, 在所有 Go 提交中击败了87.59%的用户

整数反转

给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。

如果反转后整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ，就返回 0。

假设环境不允许存储 64 位整数（有符号或无符号）。

示例 1：

输入：x = 123
输出：321

示例 2：

输入：x = -123
输出：-321

示例 3：

输入：x = 120
输出：21

func reverse(x int) int {
  n:=0
  for (x!=0){
      n=n*10+x%10
      x=x/10
  }
    if(n<(-2147483648))||(n>(2147483647)){
      n=0
  }
 // max := int(^uint32((0)) >> 1)
 // min := ^max
 // if(nmax){
 //     n=0
 // }
  //if(n<(-2^31))||(n>(2^31-1)){ //go语言中^表示按位异或  不是次方  pow(2, 32)
  //    n=0
  //}
  return n
}
执行用时：0 ms, 在所有 Go 提交中击败了100.00%的用户
内存消耗：2.1 MB, 在所有 Go 提交中击败了64.87%的用户

无符号整型uint，其最小值是0，其二进制表示的所有位都为0，

const UINT_MIN uint = 0

其最大值的二进制表示的所有位都为1，那么，

const UINT_MAX = ^uint(0)

有符号整型int，根据补码，其最大值二进制表示，首位0，其余1，那么，

const INT_MAX = int(^uint(0) >> 1)

根据补码，其最小值二进制表示，首位1，其余0，那么，

const INT_MIN = ^INT_MAX

回文数

给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。

回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，121 是回文，而 123 不是。

示例 1：

输入：x = 121
输出：true

示例 2：

输入：x = -121
输出：false
解释：从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。

func isPalindrome(x int) bool {
   i:=0
   a:=x
   if x<0{
   	return false
   }
   for x!=0{
	   i=i*10+x%10
	   x=x/10
   }
  if i==a{
  	return true
  }else {
  	return false
  }
}
执行用时：20 ms, 在所有 Go 提交中击败了47.91%的用户
内存消耗：4.9 MB, 在所有 Go 提交中击败了91.25%的用户

罗马数字转整数

罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。

字符 数值

I             1
V             5
X             10
L             50
C             100
D             500
M             1000

例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。

func romanToInt(s string) int {
	var mm = []struct { 
		value  string
		b int
	}{
		{"M", 1000},
		{"CM", 900},
		{"D", 500},
		{"CD", 400},
		{"C",100},
		{"XC", 90},
		{"L",50},
		{"XL", 40},
		{"X", 10},
		{"IX", 9},
		{"V", 5},
		{"IV",4},
		{"I",1},
	}
x:=0
var ss string
for j:=0;j<len(s);j++{
	if j+1<len(s) {
		ss = string(s[j]) + string(s[j+1]) //判断组合
	}else {
		ss="d"   //遍历从上到下"MDCXCV" 防止XC  在V前面计算
	}
	println(ss)
	for _,a:=range mm{

		if ss==a.value{
			x=x+a.b
			j=j+1    //for循环后面还要再++  所以+1
			break
		}
		if j==len(s){
			return x
		}
		if string(s[j])==a.value{
			x=x+a.b
			break
		}
	}
}
return x
}
执行用时：24 ms, 在所有 Go 提交中击败了15.05%的用户
内存消耗：3 MB, 在所有 Go 提交中击败了57.37%的用户

var symbolValues = map[byte]int{'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}

func romanToInt(s string) (ans int) {
    n := len(s)
    for i := range s {
        value := symbolValues[s[i]]
        if i < n-1 && value < symbolValues[s[i+1]] {
            ans -= value
        } else {
            ans += value
        }
    }
    return
}

最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 “”。

示例 1：

输入：strs = ["flower","flow","flight"]
输出："fl"

func longestCommonPrefix(strs []string) string {
	x:=make([]rune,0,200)
	if strs == nil {
		return string(x)
	} else {             //不为空时
		lens:=len(strs[0])
		for i:=0;i<len(strs);i++{    //找出子串最小长度
            if lens>len(strs[i]){
            	lens=len(strs[i])
			}
		}
		i, j := 0, 0
		for j<lens {                  //到最小长度停止
			d := strs[i][j]
			for i:=0;i < len(strs); {    
				if d == strs[i][j] {
					i++
				} else {
					return string(x)
				}
				if i == len(strs) {       //遍历到后面  加进去
					x = append(x, rune(d))
				}
			}
			j++
		}

	}
	return string(x)
}
执行用时：0 ms, 在所有 Go 提交中击败了100.00%的用户
内存消耗：2.3 MB, 在所有 Go 提交中击败了89.99%的用户

有效的括号

给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。

示例 1：

输入：s = "()"
输出：true

type Stack struct {            //定义栈
	size int
	top  int
	data []string
}
func isValid(s string) bool {
	s1 := Stack{}                  //初始化栈
	s1.size = len(s)
	s1.top = -1
	s1.data = make([]string, len(s))
	for _, a := range s {             //遍历s
		var b string
		if string(a) == ")" {           //设置出栈条件
			b = "("
		}
		if string(a) == "}" {
			b = "{"
		}
		if string(a) == "]" {
			b = "["
		}
		if s1.top > -1 && s1.data[s1.top] == b { //相等出栈
			s1.top--
		} else {                                //不等入栈
			s1.top++
			s1.data[s1.top] = string(a)
		}
	}
	if s1.top == -1 {                             //判断栈空为true
		return true
	} else {
		return false
	}
}
执行用时：0 ms, 在所有 Go 提交中击败了100.00%的用户
内存消耗：2.1 MB, 在所有 Go 提交中击败了17.24%的用户

合并两个有序链表

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]

func mergeTwoLists(L1 *ListNode, L2 *ListNode) *ListNode {
	L3 := &ListNode{-200, L1}               //设置L3.Next=L1
	head := L3                              //头指针
	for L1 != nil && L2 != nil {
		if L1.Val >= L2.Val {                 // 指向小的
			head.Next = L2
			println(head.Val)
			head = head.Next
			L2 = L2.Next
		} else {
			head.Next = L1
			println(head.Val)
			head = head.Next
			L1 = L1.Next
		}
	}
	if L2 != nil {                          //那个不为空 指向它 添到后面
		head.Next = L2
	}
	if L1 != nil {
		head.Next = L1
	}
	return L3.Next
}
执行用时：0 ms, 在所有 Go 提交中击败了100.00%的用户
内存消耗：2.5 MB, 在所有 Go 提交中击败了42.80%的用户

删除有序数组中的重复项

给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。

不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
int len = removeDuplicates(nums);
// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

示例 1：
输入：nums = [1,1,2]
输出：2, nums = [1,2]
解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。

func removeDuplicates(nums []int) int {
	var a, b int
	if len(nums) == 0 {         //排除一些特殊情况
		return 0
	}
	if len(nums) == 1 {
		return 1
	} else {
		a = nums[0]
		j := 1
		for i := 1; i < len(nums); i++ {
			b = nums[i]
			if a != b {               //不相等的时候用b,去逐渐取代数组里面的值
				nums[j] = b             
				a = nums[j]
				j++
			}
		}
		return j
	}
}
执行用时：8 ms, 在所有 Go 提交中击败了84.52%的用户
内存消耗：4.3 MB, 在所有 Go 提交中击败了99.94%的用户

移除元素

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
int len = removeElement(nums, val);
// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

示例 1：
输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。

func removeElement(nums []int, val int) int {
	var b int
	j := 0
	for i := 0; i < len(nums); i++ {
		b = nums[i]
		if b != val {
			nums[j] = b
			j++
		}
	}
	return j
}
执行用时：0 ms, 在所有 Go 提交中击败了100.00%的用户
内存消耗：2.1 MB, 在所有 Go 提交中击败了58.62%的用户

实现strStr()

实现 strStr() 函数。

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串出现的第一个位置（下标从 0 开始）。如果不存在，则返回 -1 。

说明：

当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。

对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与 C 语言的 strstr() 以及 Java 的 indexOf() 定义相符。

示例 1：
输入：haystack = "hello", needle = "ll"
输出：2

func strStr(haystack string, needle string) int {
	n := len(needle)
	falge := false
	m := -1
	if len(needle) == 0 {    //排除特殊情况
		return 0
	}
	for a, b := range haystack {
		if b == rune(needle[0]) && falge == false {   //相等开始遍历
			m = a
			falge = true
		}
		if a+n > len(haystack) {          //防止数组越界和不必要的遍历
			return -1
		}
		if falge == true {           
			for d, c := range needle {                 
        if d == len(haystack) {     //排除len(needle)>len(haystack)的情况
					return -1
				}
				if c != rune(haystack[m]) {   //遇到不一样的返回 
					break
				}
				m++
			}
			if m-a == n {             //如果全部遍历完 一样的话 return 下标
				return a
			} else {
				falge = false
			}
		}
	}
	return m
}
执行用时：380 ms, 在所有 Go 提交中击败了11.06%的用户
内存消耗：2.6 MB, 在所有 Go 提交中击败了65.18%的用户

中等

两数相加

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。请你将两个数相加，并以相同形式返回一个表示和的链表。你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.

示例 2：
输入：l1 = [0], l2 = [0]
输出：[0]

示例 3:
输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {//传入的l1指针是ListNode结构体类型的
    dummy := &ListNode{}//定义结构体指针赋值为空
    for dy,rst :=dummy,0;l1 != nil || l2 != nil || rst !=0;dy = dy.Next{//指针指向同一位置
        if l1 != nil {
             rst += l1.Val
             l1 = l1.Next
        }
        if l2 != nil {
            rst += l2.Val
            l2 = l2.Next
        }
        dy.Next = &ListNode{Val: rst % 10}
        rst /=10
    }
    return dummy.Next
}

无重复字符的最长子串

给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: s = "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

示例 2:

输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。

func lengthOfLongestSubstring(s string) int {
	s1 := make([]rune, 0,len(s))
	max := 0
	for _, a := range s {
		flag := true
		for j, b := range s1 {
			if b == a {
				if len(s1) > max {
					max= len(s1)
				}
				s1 = s1[j+1:]
				s1 = append(s1, b)
				flag = false
			}
		}
		if flag {
			s1 = append(s1, a)
			if len(s1) > max {
				max = len(s1)
			}
		}
	}
	return max  
}
执行用时：12 ms, 在所有 Go 提交中击败了44.77%的用户
内存消耗：2.9 MB, 在所有 Go 提交中击败了55.17%的用户

最长回文子串

给你一个字符串 s，找到 s 中最长的回文子串。

示例 1：

输入：s = "babad"
输出："bab"
解释："aba" 同样是符合题意的答案。

示例 2：

输入：s = "cbbd"
输出："bb"

func longestPalindrome(s string) string {
	s1:=make([]rune,0,len(s))
	s2:=make([]rune,0,len(s))
	var l,r int
	max:=0
	min:=0
	for _,a:=range s{
		s1=append(s1,a)
	}
	lens:=len(s1)
	if lens==1{
		return string(s1[0])
	}else {
		for i:=1;i<lens;i++{
			if s1[i]==s1[i-1]{
				for l,r=i-1,i;l>=0&&r<lens;{
					if s[l]==s[r]{
						if r-l>max-min{
							max=r
							min=l
						}
						l--
						r++
					}else{
						break
					}
				}
				for l,r=i-1,i+1;l>=0&&r<lens;{
					if s[l]==s[r]{
						if r-l>max-min{
							max=r
							min=l
						}
						l--
						r++
					}else{
						break
					}
				}
			}else {
				for l,r=i-1,i+1;l>=0&&r<lens;{
					if s[l]==s[r]{
						if r-l>max-min{
							max=r
							min=l
						}
						l--
						r++
					}else{
						break
					}
				}
			}
		}
	}
	s2=s1[min:max+1]
	return string(s2)
}
执行用时：8 ms, 在所有 Go 提交中击败了67.11%的用户
内存消耗：3.4 MB, 在所有 Go 提交中击败了47.22%的用户

Z字型变换

将一个给定字符串 s 根据给定的行数 numRows ，以从上往下、从左到右进行 Z 字形排列。

比如输入字符串为 “PAYPALISHIRING” 行数为 3 时，排列如下：

P   A   H   N
A P L S I I G
Y   I   R

之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如：“PAHNAPLSIIGYIR”。

请你实现这个将字符串进行指定行数变换的函数：

string convert(string s, int numRows);

示例 1：

输入：s = "PAYPALISHIRING", numRows = 3
输出："PAHNAPLSIIGYIR"

示例 2：

输入：s = "PAYPALISHIRING", numRows = 4
输出："PINALSIGYAHRPI"
解释：
P     I    N
A   L S  I G
Y A   H R
P     I

func convert(s string, numRows int) string {
   num:=numRows
   j:=len(s)/num+num
   s1:=make([][]rune,num)
   for num:=range s1{
   	 s1[num]=make([]rune,0,j)
   }
   s2:=make([]rune,0,len(s))
   for _,a:=range s{
   	s2=append(s2,a)
   }
   i:=0
   falg:=true
 	 if num==1{
 		return s
	 }else {
	  	for _,b:=range s2{
			s1[i]=append(s1[i],b)
			if falg==false{
				i--
				if i==(-1){
					falg=true
					i=1
				}
			}else {
				i++
				if i==num{
					falg=false
					i=num-2
				}
			}
		}
		s4:=make([]rune,0,len(s))
		for nn:=range s1{
			for _,mm:=range s1[nn]{
				s4=append(s4,mm)
			}
		}
		return string(s4)
	}
}
执行用时：8 ms, 在所有 Go 提交中击败了79.04%的用户
内存消耗：7.3 MB, 在所有 Go 提交中击败了9.95%的用户

字符串转换整数

请你来实现一个 myAtoi(string s) 函数，使其能将字符串转换成一个 32 位有符号整数（类似 C/C++ 中的 atoi 函数）。

函数 myAtoi(string s) 的算法如下：

读入字符串并丢弃无用的前导空格
检查下一个字符（假设还未到字符末尾）为正还是负号，读取该字符（如果有）。 确定最终结果是负数还是正数。 如果两者都不存在，则假定结果为正。
读入下一个字符，直到到达下一个非数字字符或到达输入的结尾。字符串的其余部分将被忽略。
将前面步骤读入的这些数字转换为整数（即，“123” -> 123， “0032” -> 32）。如果没有读入数字，则整数为 0 。必要时更改符号（从步骤 2 开始）。
如果整数数超过 32 位有符号整数范围 [−231, 231 − 1] ，需要截断这个整数，使其保持在这个范围内。具体来说，小于 −231 的整数应该被固定为 −231 ，大于 231 − 1 的整数应该被固定为 231 − 1 。
返回整数作为最终结果。
注意：

本题中的空白字符只包括空格字符 ’ ’ 。
除前导空格或数字后的其余字符串外，请勿忽略 任何其他字符。

func myAtoi(s string) int {
	var x int =0
	var falg bool = true
	s2:=make([]rune,0,len(s))
	for _,n:=range s{      //去掉前面空格
		if n==' '{
			if len(s2)==0{
				continue
			}else {
				s2=append(s2,n)
			}
		}else  {

			s2=append(s2,n)
		}

	}
	if len(s2)==0{
		return 0
	}
	s1:=make([]rune,0,len(s2))
	i:=0
	if s2[i]=='+'{
		i++
	}else if s2[i]=='-'{
		i++
		falg=false
	}else if s2[i]>57||s2[i]<48{
		return 0
	}
	for i<len(s2){
		if s2[i]>=48&&s2[i]<=57{   //数字加入字符串
			s1=append(s1,s2[i])
			i++
		}else{
			break
		}
	}
	s=string(s1)
	x, _ = strconv.Atoi(s)   //字符串 转换为int 型
	if falg==true{    //判断正负
		x=x
	}else{
		x=-x
	}
	 if x>(2147483647){   //判断范围
		x=2147483647

	}else if x<(-2147483648){
		x=-2147483648
	 }
	return x
}
执行用时：0 ms, 在所有 Go 提交中击败了100.00%的用户
内存消耗：2.4 MB, 在所有 Go 提交中击败了11.08%的用户

盛最多水的容器

给你 n 个非负整数 a1，a2，…，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0) 。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

说明：你不能倾斜容器。

示例 1：

输入：[1,8,6,2,5,4,8,3,7]
输出：49
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

func maxArea(height []int) int {
	i:=0
	j:=len(height)-1     //i,j分别指向首尾
	var ss,max,ii int
	 for   i<j{
		 if height[i]<height[j]{ 
			 ss=height[i]       //ss=最小值
		 }else {
			 ss=height[j]
		 }
		 ii = ss*(j-i)        //容积
		 ss=ss+1              //ss逐渐增大，两边不够的逐渐排除
		 if height[i]<ss{     
		 	i++
		 }
		 if height[j]<ss{
		 	j--
		 }
	 	if max>ii{         //只保存最大值
	 		max=max
		}else {
			max=ii
		}
	 }
return max
}
执行用时：84 ms, 在所有 Go 提交中击败了22.36%的用户
内存消耗：8.6 MB, 在所有 Go 提交中击败了14.00%的用户

整数转罗马数字

罗马数字包含以下七种字符： I， V， X， L，C，D 和 M。

字符          数值
I             1
V             5
X             10
L             50
C             100
D             500
M             1000

例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
给你一个整数，将其转为罗马数字。

func intToRoman(num int) string {
	x:=make([]rune,0,10)
	for num!=0{
	var m int
	m=(num/1000)
	if m==0{
		var d int
		d=num/500
		if d==0{
			var c int
			c=num/100
			if c==0{
				var l int
				l=num/50
				if l==0{
					var xx int
					xx=num/10
					if xx==0{
						var v int
						v=num/5
						if v==0{
							if num==4{
								x=append(x,'I')
								x=append(x,'V')
								num=0
							}else{
								for i:=0;i<num;i++{
									x=append(x,'I')
								}
								num=0
							}
						}else{
							if num/9==1{
								x=append(x,'I')
								x=append(x,'X')
								num=0
							}else{
								x=append(x,'V')
								for i:=0;i<(num%5);i++{
									x=append(x,'I')
								}
								num=0
							}
						}
					}else {
						if xx==4{
							x=append(x,'X')
							x=append(x,'L')
							num=num%10
						}else {
							for i:=0;i<xx;i++{
								x=append(x,'X')
							}
							num=num%10
						}
					}
				}else {
					if num/90==1{
						x=append(x,'X')
						x=append(x,'C')
						num=num%10
					}else{
						x=append(x,'L')
						for i:=0;i<(num/10)-5;i++{
							x=append(x,'X')
						}
						num=num%10
					}
				}
			}else if c==4{
				x=append(x,'C')
				x=append(x,'D')
				num=num%100
			 }else{
				for i:=0;i<c;i++{
					x=append(x,'C')
					num=num%100
				}
			}
		}else{
			if num/900==1{
				x=append(x,'C')
				x=append(x,'M')
				num=num%100
			}else {     //d==1的情况 678
				x=append(x,'D')
				for i:=0;i<((num/100)-5);i++{
					x=append(x,'C')
				}
				num=num%100
			}
		}

	}else {
		for i:=0;i<m;i++{
			x=append(x,'M')
		}
		num=num%1000
	}

	}
	return string(x)
}

执行用时：4 ms, 在所有 Go 提交中击败了94.18%的用户
内存消耗：3.3 MB, 在所有 Go 提交中击败了91.04%的用户

var valueSymbols = []struct {   //标准答案  想复杂了
    value  int
    symbol string
}{
    {1000, "M"},
    {900, "CM"},
    {500, "D"},
    {400, "CD"},
    {100, "C"},
    {90, "XC"},
    {50, "L"},
    {40, "XL"},
    {10, "X"},
    {9, "IX"},
    {5, "V"},
    {4, "IV"},
    {1, "I"},
}

func intToRoman(num int) string {
    roman := []byte{}
    for _, vs := range valueSymbols {
        for num >= vs.value {
            num -= vs.value
            roman = append(roman, vs.symbol...)
        }
        if num == 0 {
            break
        }
    }
    return string(roman)
}

三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

func threeSum(nums []int) [][]int {
	s1:=make([][]int,0)
if len(nums)<3{       //前期处理
	return s1
}
for i:=0;i<len(nums);i++{     //数组排序
	for j:=i+1;j<len(nums);j++{
		if nums[i]>nums[j]{
			nums[i],nums[j]=nums[j],nums[i]
		}
	}
}
flag:=false                  //给一个标记
for k:=0;nums[k]<=1&&k<len(nums)-2;k++{    //循环往后找
	j:=len(nums)-1
	for i:=k+1;i<j;{
		if nums[k]+nums[i]+nums[j]>0{          //大于0  后面太大了  向前走
			j--
			continue
		}
		if nums[k]+nums[i]+nums[j]<0{           //小于0  前面太小了  向后走
			i++
			continue
		}
		if nums[k]+nums[i]+nums[j]==0{           //等于0   插入数组
				if len(s1)==0{                           //判断是否为第一组 感觉有点多余
					s1=append(s1,[]int{nums[k],nums[i],nums[j]})
					i++                                  //i++ continue不要在往后了
					continue
				}else{
					for _,d:=range s1{                  //先遍历一遍去重
						if len(d)>0{
						if nums[k]==d[0]&&nums[i]==d[1]&&nums[j]==d[2] {
							flag=true                      //找到了 改标记
							break
						}
						}else {
							break
						}
					}
					if flag==false{                   //看标记插入
						s1=append(s1,[]int{nums[k],nums[i],nums[j]})
						i++
						continue
					}
					flag=false
				}
				i++
		}
	}
}
return s1
}
执行用时：324 ms, 在所有 Go 提交中击败了7.65%的用户
内存消耗：7.4 MB, 在所有 Go 提交中击败了92.49%的用户

func threeSum(nums []int) [][]int {
    n := len(nums)
    sort.Ints(nums)    //排序
    ans := make([][]int, 0)
    // 枚举 a
    for first := 0; first < n; first++ {
        // 需要和上一次枚举的数不相同
        if first > 0 && nums[first] == nums[first - 1] {
            continue
        }
        // c 对应的指针初始指向数组的最右端
        third := n - 1
        target := -1 * nums[first]
        // 枚举 b
        for second := first + 1; second < n; second++ {
            // 需要和上一次枚举的数不相同
            if second > first + 1 && nums[second] == nums[second - 1] {
                continue
            }
            // 需要保证 b 的指针在 c 的指针的左侧
            for second < third && nums[second] + nums[third] > target {
                third--
            }
            // 如果指针重合，随着 b 后续的增加
            // 就不会有满足 a+b+c=0 并且 b
            if second == third {
                break
            }
            if nums[second] + nums[third] == target {
                ans = append(ans, []int{nums[first], nums[second], nums[third]})
            }
        }
    }
    return ans
}

最接近的三数之和

给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。

示例：

输入：nums = [-1,2,1,-4], target = 1
输出：2
解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。

func threeSumClosest(nums []int, target int) int {
	sort.Ints(nums)            //排序
	j := len(nums) - 1
	max := nums[0] + nums[1] + nums[2]
	aa := float64(max - target)
	cc := math.Abs(aa)
	for k := 0; k < j-1; k++ {    //循环遍历
		j = len(nums) - 1
		for i := k + 1; i < j; {
			kij := nums[k] + nums[i] + nums[j]
			hhl := float64(kij - target)
			bb := math.Abs(hhl)

			if kij < target {     //小了 加一个

				if cc > bb {
					cc = bb
					max = kij
				}
				i++
			} else if kij > target {    //大了 减一个

				if cc > bb {
					cc = bb
					max = kij
				}
				j--
			} else {
				return kij
			}
		}
	}
	return max
}
执行用时：4 ms, 在所有 Go 提交中击败了96.46%的用户
内存消耗：2.7 MB, 在所有 Go 提交中击败了66.12%的用户

电话号码的字母组合

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

示例 1：

输入：digits = "23"
输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]

var ss = [8][]string{     //设二维数组
	{"a", "b", "c"},
	{"d", "e", "f"},
	{"g", "h", "i"},
	{"j", "k", "l"},
	{"m", "n", "o"},
	{"p", "q", "r", "s"},
	{"t", "u", "v"},
	{"w", "x", "y", "z"},
}
func letterc(a []string, b []string) []string {   //设置函数处理两个数组
	var cc []string
	for i := 0; i < len(a); i++ {
		for j := 0; j < len(b); j++ {
			cc = append(cc, a[i]+b[j])
		}
	}
	return cc
}
func letterCombinations(digits string) []string {
	var cc []string
	var digitsint []int
	for _, d := range digits {      //处理一下字符串 转int  匹配对应数组
		dint, _ := strconv.Atoi(string(d))
		digitsint = append(digitsint, dint)
	}
	if len(digits) == 0 {
		return cc
	}
	if len(digits) == 1 {           //分情况讨论
		cc := ss[digitsint[0]-2]
		return (cc)
	}
	if len(digits) == 2 {
		a := ss[digitsint[0]-2]
		b := ss[digitsint[1]-2]
		cc = letterc(a, b)
		return cc
	} else {                        //大于等于3的情况
		a := ss[digitsint[0]-2]
		b := ss[digitsint[1]-2]
		cc = letterc(a, b)
		for i := 2; i < len(digits); i++ {
			aaa := ss[digitsint[i]-2]
			cc = letterc(cc, aaa)
		}
		return cc
	}
}
执行用时：0 ms, 在所有 Go 提交中击败了100.00%的用户
内存消耗：2.1 MB, 在所有 Go 提交中击败了21.63%的用户

四数之和

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按 任意顺序 返回答案 。

示例 1：

输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

func fourSum(nums []int, target int) [][]int {
	sort.Ints(nums) //数组排序
	s1 := make([][]int, 0)
	if len(nums) < 4 {
		return s1
	}
	flag := true
	for m := 0; m < len(nums); m++ {
		for n := m + 1; n < len(nums)-2; n++ {
			j := len(nums) - 1
			for i := n + 1; i < j; {
				num := nums[m] + nums[n] + nums[i] + nums[j]
				if num < target {
					i++
				}
				if num > target {
					j--
				}
				if num == target {
						for _, d := range s1 { //先遍历一遍去重
							if len(d) > 0 {
						if nums[m] == d[0] && nums[n] == d[1] && nums[i] == d[2] && nums[j] == d[3] {
									flag = false //找到了 改标记
									break
								}
							} else {
								break
							}
						}
						if flag == true { //看标记插入
							s1 = append(s1, []int{nums[m], nums[n], nums[i], nums[j]})
							i++
							continue
						}
						flag = true

					i++
				}
			}
		}
	}
	return s1
}
执行用时：28 ms, 在所有 Go 提交中击败了15.10%的用户
内存消耗：2.9 MB, 在所有 Go 提交中击败了24.59%的用户

删除链表的倒数第N个节点

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

**进阶：**你能尝试使用一趟扫描实现吗？

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

package main

type ListNode struct {
	Val  int
	Next *ListNode
}

func removeNthFromEnd(head *ListNode, n int) *ListNode {
	p := head      //设两个指针指向头指针
	q := head
	c := 0         //给出计数
	if head.Next == nil {         //排除特殊情况
		return head.Next
	}
	for head.Next != nil {       
		if c == n {
			p = p.Next
		} else {
			c++                      //计数 直到c==n
		}
		head = head.Next
	}
	if c == n {                  //去掉这个数
		p.Next = p.Next.Next
	}
  if c < n {                   //排除n==len(数组)
		return q.Next
	}
	return q
}
func main() {
	list := []int{1, 2, 3, 4, 5}
	head := &ListNode{Val: list[0]}
	tail := head
	for i := 1; i < len(list); i++ {
		head.Next = &ListNode{Val: list[i]}
		head = head.Next
	}
	println(tail.Val)
	println(tail.Next.Val)
	n := 2
	x := removeNthFromEnd(tail, n)
	print(x)
}

执行用时：0 ms, 在所有 Go 提交中击败了100.00%的用户
内存消耗：2.2 MB, 在所有 Go 提交中击败了99.97%的用户

括号生成

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。

有效括号组合需满足：左括号必须以正确的顺序闭合。

示例 1：
输入：n = 3
输出：["((()))","(()())","(())()","()(())","()()()"]

示例 2：
输入：n = 1
输出：["()"]

func generateParenthesis(n int) []string {
s=make([]string,0)                    //不能为var s []string   append 插不进去
generate(n,0,0,"")                       //设置一个函数 递归调用
return s
}
func generate(n int,l int ,r int,cur string){
	if r==n&&l==n{                        //左括号数量=右括号数量=n时  插入数组切片
		s=append(s,cur)
		return
	}
	if l<n{                              //左括号数量小于n时 cur加入“（”
		generate(n,l+1,r,cur+"(")
	}
  if r<n&&r<l{                          //右括号数量小于n切 右括号的数量要小于左括号 cur+")"
		generate(n,l,r+1,cur+")")
	}
}
执行用时：0 ms, 在所有 Go 提交中击败了100.00%的用户
内存消耗：2.7 MB, 在所有 Go 提交中击败了71.77%的用户

两两交换链表中的节点

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

输入：head = [1,2,3,4]
输出：[2,1,4,3]

func swapPairs(head *ListNode) *ListNode {
	var p, q, m *ListNode             //定义三个指针
	if head == nil {
		return head
	} else {
		he := &ListNode{Val: -1, Next: head} 
		m = he                          //m始终指向p,q前面
		p = head                        //p在前
		q = head.Next                   //q在后
		for p != nil && q != nil {
			p.Next = q.Next
			q.Next = p                    //交换
			m.Next = q
			m = p                         //m跟上
			p = p.Next
			if p == nil {                 //结束条件
				break
			}
			q = p.Next
		}
		return he.Next
	}
}
执行用时：0 ms, 在所有 Go 提交中击败了100.00%的用户
内存消耗：2.1 MB, 在所有 Go 提交中击败了56.09%的用户

两数相除

给定两个整数，被除数 dividend 和除数 divisor。将两数相除，要求不使用乘法、除法和 mod 运算符。

返回被除数 dividend 除以除数 divisor 得到的商。

整数除法的结果应当截去（truncate）其小数部分，例如：truncate(8.345) = 8 以及 truncate(-2.7335) = -2

示例 1:
输入: dividend = 10, divisor = 3
输出: 3
解释: 10/3 = truncate(3.33333..) = truncate(3) = 3

func dd(a int, b int) int {      //返回两个正数的除后的值
	if b == 1 {             //排除b==1的情况
		return a
	}
	if a > b {
		i := 1
		d := b                      //给个记录
		for a > b {
			b = b << 1                 //    <<1 相当于乘2
			i = i << 1
		}
		if a < b {                    //证明给高了
			b = b >> 1                   //除回来
			i = i >> 1
			c := a - b
			for c >= d {                 //用简单的加法
				c = c - d
				i++ 
			}
		} 
		return i                 //返回
	} else if a == b {       //a==b的情况
		return 1
	} else {                  //a
		return 0
	}
}
func divide(dividend int, divisor int) int {
	if dividend == 0 {
		return 0
	}
	var b int
	if dividend < 0 {       //保证给上面函数提供两个正数
		if divisor > 0 {
			c := dd((-dividend), divisor)
			b = -c               //根据情况加负号
		} else {
			c := dd(-dividend, -divisor)
			b = c
		}
	} else {
		if divisor > 0 {
			c := dd(dividend, divisor)
			b = c
		} else {
			c := dd(dividend, -divisor)
			b = -c
		}
	}
	if b > (2147483647) { //判断范围
		b = 2147483647
	} else if b < (-2147483648) {
		b = -2147483648
	}
	return b
}
执行用时：364 ms, 在所有 Go 提交中击败了58.55%的用户
内存消耗：2.5 MB, 在所有 Go 提交中击败了5.12%的用户

困难

寻找两个正序数组的中位数

给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。

示例 1：
输入：nums1 = [1,3], nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3] ，中位数 2

示例 2：
输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5

func findMedianSortedArrays(nums1 []int, nums2 []int) float64 {
	var i,j,m,n,u int
	m=len(nums1)
	n=len(nums2)
	if n<m {
		nums1,nums2=nums2,nums1
		m,n=n,m
	}
	var x float64
	nums3:=make([]int,n+m)
	i,u=0,0
    for  i<m || j<n {
		if i==m{
			for j<n{
				nums3[u]=nums2[j]
				u++
				j++
			}
		}else if j==n{
			for i<m{
				nums3[u]=nums1[i]
				i++
				u++
			}
		}else if i<m||j<n {
			if nums1[i] <= nums2[j] {
				nums3[u] = nums1[i]
				println(nums3[u])
				u++
				i++
			} else {
				nums3[u] = nums2[j]
				println(nums3[u])
				u++
				j++
			}
		}
	}
	var a,b,y int
	a=(m+n)%2
	b=(m+n)/2
	if a==0{
		x=(float64(nums3[b-1]+nums3[b]))/2
	}else {
		b=(m+n)/2
		x=float64(nums3[b])
		println(y)
	}
	return x
}

正则表达式匹配

给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 ‘.’ 和 ‘*’ 的正则表达式匹配。

‘.’ 匹配任意单个字符
‘*’ 匹配零个或多个前面的那一个元素
所谓匹配，是要涵盖 整个 字符串 s的，而不是部分字符串。

示例 1：

输入：s = "aa" p = "a"
输出：false
解释："a" 无法匹配 "aa" 整个字符串。

示例 2:

输入：s = "aa" p = "a*"
输出：true
解释：因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 'a'。因此，字符串 "aa" 可被视为 'a' 重复了一次。

func isMatch(s string, p string) bool {
	if len(p) == 0 { //排除p==0的情况
		if len(s) != 0 {
			return false
		}
		return true
	}
	if len(s) == 0 {   //排除S等于0的情况
		if len(p) == 0 {
			return false
		}
		for i := 0;i < len(p); {   //P不等于0
			if p[i] != '*' {       //'*' 匹配零个或多个前面的那一个元素
				if i+1 < len(p)  && p[i+1] == '*'{
					i+=2         //a* 相当于没有 跳到后面检查
					continue
				}
				return false
			}else {  //如果p[i] =='*'  return true
				 return true
			}
		}
		return true
	}
	ss, pp := s[0], p[0]
	if ss == pp || pp == '.' {
		if len(p) == 1 {
			return isMatch(s[1:], p[1:])
		} else {
			if p[1] == '*' {
				match := isMatch(s, p[2:])  // p[1] == '*' 前面可以抵消 返回后面再查一遍
				if match {
					return true
				}
				match = isMatch(s[1:], p)    //确保第一个匹配   'aa'  'a*'
				if match {
					return true
				}
			} else {   //都没有问题 s,p缩短一位
				return isMatch(s[1:], p[1:])
			}
		}
	} else {   //ss ！= pp || pp ！= '.'
		if len(p) == 1 {
			return false
		} else {
			if p[1] == '*' {
				return isMatch(s, p[2:])
			}
		}
	}
	return false
}
执行用时：12 ms, 在所有 Go 提交中击败了15.89%的用户
内存消耗：2.1 MB, 在所有 Go 提交中击败了94.79%的用户

合并K个生序链表

给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

示例 1：
输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
  1->4->5,
  1->3->4,
  2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6

type ListNode struct {
	Val  int
	Next *ListNode
}
func mergeKLists(lists []*ListNode) *ListNode {
	var p, q, he *ListNode
	if len(lists) == 0 {
		return p
	}
	head := &ListNode{Val: 100000, Next: lists[0]}
		for i := 1; i < len(lists); i++ {
			he = head                //始终操作第一个数组
			p = head.Next           
			q = lists[i]             //q逐个代表后面的数组 插入第一个数组中
			for q != nil && p != nil {         //和正常两个链表合并一样
				if p.Val <= q.Val {
					he.Next = p
					he = he.Next
					p = p.Next
				} else {
					he.Next = q
					he = he.Next
					q = q.Next
				}
			}
			if q != nil {
				he.Next = q
			}
			if p != nil {
				he.Next = p
			}
		}
	return head.Next
}
func main() {
	var lists = [][]int{
		{1, 4, 5},
		{1, 3, 4},
		{2, 6},
	}
	var tt []*ListNode             //定义指针数组
	for i := 0; i < len(lists); i++ {       //逐个遍历生成指链表
		head := &ListNode{Val: lists[i][0]}
		tail := head
		for j := 1; j < len(lists[i]); j++ {
			head.Next = &ListNode{Val: lists[i][j]}
			head = head.Next
		}
		tt = append(tt, tail)         //插入指针数组
	}
	println(tt[0].Val)
	x := mergeKLists(tt)
	for x != nil {
		print(x.Val)
		x = x.Next
	}
}
执行用时：104 ms, 在所有 Go 提交中击败了28.10%的用户
内存消耗：5.3 MB, 在所有 Go 提交中击败了54.40%的用户

K个一组翻转链表

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。

k 是一个正整数，它的值小于或等于链表的长度。

如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

输入：head = [1,2,3,4,5], k = 2
输出：[2,1,4,3,5]

输入：head = [1,2,3,4,5], k = 3
输出：[3,2,1,4,5]

func reverselist(head *ListNode) (l *ListNode, r *ListNode) { 
	var p, q, m *ListNode    //翻转函数，输入123，返回321 的头尾指针
	p = head
	q = head.Next
	m = q.Next
	if m == nil {
		q.Next = p
		p.Next = nil
		return q, p
	}
	for q != nil {
		q.Next = p
		p = q
		q = m
		if m.Next != nil {
			m = m.Next
		} else {
			q.Next = p
			break
		}
	}
	head.Next = nil
	return q, head
}
func reverseKGroup(head *ListNode, k int) *ListNode {
	var pp, qq, h, l, r, left, right *ListNode
	i := 1
	if k == 1 {
		return head
	}
	pp = head
	qq = pp
	for pp.Next != nil {
		pp = pp.Next
		i++
		if i == k {    //相等了就调用上面函数翻转一下
			i = 1
			h = pp
			pp = pp.Next
			h.Next = nil
			l, r = reverselist(qq)
			if left == nil && right == nil {
				left = l
				right = r
			} else {
				right.Next = l             //首尾相接
				right = r
			}
			qq = pp
			if pp == nil {
				break
			}
		}
	}
	right.Next = qq                  //接上剩余部分
	return left
}
执行用时：4 ms, 在所有 Go 提交中击败了90.01%的用户
内存消耗：3.6 MB, 在所有 Go 提交中击败了99.95%的用户

串联所有单词的子串

给定一个字符串 s 和一些 长度相同 的单词 words 。找出 s 中恰好可以由 words 中所有单词串联形成的子串的起始位置。

注意子串要与 words 中的单词完全匹配，中间不能有其他字符 ，但不需要考虑 words 中单词串联的顺序。

示例 1：
输入：s = "barfoothefoobarman", words = ["foo","bar"]
输出：[0,9]
解释：
从索引 0 和 9 开始的子串分别是 "barfoo" 和 "foobar" 。
输出的顺序不重要, [9,0] 也是有效答案。

//此方法可以得到答案 ，但是超时了
func findblock(s []string, words []string, ) bool {
	wordss := make([]bool, 0)
	for a := 0; a < len(words); a++ {   //给words加一个标签 ，遍历到就改变
		wordss = append(wordss, false)
	}
	b := 0
	for i := 0; i < len(s); i++ {
		for j := 0; j < len(words); j++ {
			if s[i] == words[j] && wordss[j] == false {   //遍历到就改变
				wordss[j] = true
				b++                //计数加一
				break
			}
		}
	}
  if b == len(words) {       //计数等于len(words)长度 证明全部遍历过了
		return true
	} else {
		return false
	}
}
func findSubstring(s string, words []string) []int {
	c := make([]int, 0)
	blocklen := len(words) * len(words[0]) //滑块长度

	for i := 0; i < len(s)-blocklen+1; i++ {
		s1 := s[i : i+blocklen] //滑块
		s2 := make([]string, 0, len(words))
		for j := 0; j < len(s1)-len(words[0])+1; {

			s2 = append(s2, s1[j:j+len(words[0])]) //将滑块分块
			j += len(words[0])

		}
		if findblock(s2, words) { //匹配函数
			c = append(c, i) //匹配成功将i 加入
		}
	}
	return c
}

//修改版
func findblock(s []string, wordsreceive map[string]int) bool {
	wordsreceive2 := make(map[string]int, 0)
	falge := true
	for i := 0; i < len(s); i++ {
		if a, ok := wordsreceive[s[i]]; ok { //如果查到的话
			if b, ok := wordsreceive2[s[i]]; ok {
				if b < a { //如果查到了 但b
					wordsreceive2[s[i]] = b + 1
				} else {
					falge = false
					break
				}
			} else { //第一次肯定查不到
				wordsreceive2[s[i]] = 1 //插入进去
			}
		} else {
			falge = false //没查到
			break
		}
	}
	return falge
}
func findSubstring(s string, words []string) []int {
	c := make([]int, 0)
	blocklen := len(words) * len(words[0]) //滑块长度

	wordsreceive := make(map[string]int, 0) //创建一个字典，出现相同字典+1
	for _, bb := range words {
		wordsreceive[bb] = wordsreceive[bb] + 1
		println(wordsreceive[bb])
	}
  
	for i := 0; i < len(s)-blocklen+1; i++ {
		s1 := s[i : i+blocklen] //滑块
		s2 := make([]string, 0, len(words))
		for j := 0; j < len(s1)-len(words[0])+1; {
			s2 = append(s2, s1[j:j+len(words[0])]) //将滑块分块
			j += len(words[0])
		}
		if findblock(s2, wordsreceive) { //匹配函数
			c = append(c, i) //匹配成功将i 加入
		}
	}
	return c
}
执行用时：56 ms, 在所有 Go 提交中击败了46.46%的用户
内存消耗：7.2 MB, 在所有 Go 提交中击败了31.31%的用户