for j < len(elemList) {
	// Need to compare j with the closest value within range [i, j-1]
	if elemList[j].val-elemList[i].val <= t {
		if abs(elemList[j].idx-elemList[i].idx) <= k {
			return true
		}
		j++
	} else {
		i++
		if j <= i {
			j++
		}
	}
}

	for p2.Next != nil && p2.Next.Next != nil {
		p1 = p1.Next
		p2 = p2.Next.Next
	}

go: finding github.com/halfrost/LeetCode-Go/structures latest
go: finding github.com/halfrost/LeetCode-Go latest
go: extracting github.com/halfrost/LeetCode-Go v0.0.0-20200828032122-2363839e94c6
-> unzip /home/peng/code/pkg/mod/cache/download/github.com/halfrost/!leet!code-!go/@v/v0.0.0-20200828032122-2363839e94c6.zip: malformed file path "leetcode/0118.Pascals-Triangle/118. Pascal's Triangle.go": invalid char '\''

func threeSum(nums []int) [][]int {
	sort.Ints(nums)
	var (
		result = make([][]int, 0)
		start, end, index, addNum int
		length = len(nums)
	)
	if length > 0 && (nums[0] > 0 || nums[length -1 ] < 0) {
		return result
	}
	for index = 1; index < length - 1; index++ {
		start, end = 0, length - 1
		if index > 1 && nums[index] == nums[index - 1]{
			start = index - 1
		}
		for start < index && end > index {
			if start > 0 && nums[start] == nums[start - 1]{
				start++
				continue
			}
			if end < length-1 && nums[end] == nums[end+1]{
				end--
				continue
			}
			addNum = nums[start] + nums[end] + nums[index]
			if addNum == 0 {
				result = append(result, []int{nums[start], nums[index], nums[end]})
				start ++
				end --
			} else if addNum > 0 {
				end--
			} else {
				start++
			}
		}
	}
	return result
}

func mergeTwoLists148(l1 *ListNode, l2 *ListNode) *ListNode {
	if l1 == nil {
		return l2
	}
	if l2 == nil {
		return l1
	}
	if l1.Val < l2.Val {
		l1.Next = mergeTwoLists(l1.Next, l2)
		return l1
	}
	l2.Next = mergeTwoLists(l1, l2.Next)
	return l2
}

func mergeTwoLists(l1 *ListNode, l2 *ListNode) *ListNode {
	if l1 == nil {
		return l2
	}
	if l2 == nil {
		return l1
	}
	if l1.Val < l2.Val {
		l1.Next = mergeTwoLists(l1.Next, l2)
		return l1
	}
	l2.Next = mergeTwoLists(l1, l2.Next)
	return l2
}

dp := make([]int, len(words))
for i := len(words) - 1; i >= 0; i-- {
	dp[i] = 1
	for j := poss[len(words[i])+1]; j < len(words) && len(words[j]) == len(words[i])+1; j++ {
		if isPredecessor(words[j], words[i]) {
			dp[i] = max(dp[i], 1+dp[j])
		}
	}
	res = max(res, dp[i])
}
return res

Error: API rate limit exceeded for app ID 75d9d747f200c623a0e6..

func lengthOfLongestSubstring(s string) int {
	if len(s) == 0 {
		return 0
	}
	// 扩展 ASCII 码的位图表示（BitSet），共有 256 位
	var bitSet [256]uint8
	result, left, right := 0, 0, 0
	for left < len(s) {
		if right < len(s) && bitSet[s[right]] == 0 {
			// 标记对应的 ASCII 码为 1
			bitSet[s[right]] = 1
			right++
		} else {
			// 标记对应的 ASCII 码为 0
			bitSet[s[left]] = 0
			left++
		}
		result = max(result, right-left)
	}
	return result
}

		for i := len(nums) - 1; i >= 0; i-- {
			tmp := count[(nums[i]/exp)%10]
			tmp--
			aux[tmp] = nums[i]
		}

		for i := len(nums) - 1; i >= 0; i-- {
			tmp := count[(nums[i]/exp)%10]
			tmp--
			aux[tmp] = nums[i]
			count[(nums[i]/exp)%10] = tmp
		}

func diagonalSum(mat [][]int) int {
    n := len(mat)
    ans := 0
    for pi := 0; pi < n; pi++ {
        ans += mat[pi][pi]
    } 
    for si, sj := n - 1, 0; sj < n; si, sj = si - 1, sj + 1 {
        ans += mat[si][sj]
    }
    if n % 2 == 0 {
        return ans
    }
    return ans - mat[n / 2][n / 2]
}

var blocker = [][]int{
	//  1  2  3  4  5  6  7  8  9   // first column is added so we use 1-9
	{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // 0 phantom node. as the STARTING point
	{0, 0, 0, 2, 0, 0, 0, 4, 0, 5}, // 1
	{0, 0, 0, 0, 0, 0, 0, 0, 5, 0}, // 2
	{0, 2, 0, 0, 0, 0, 0, 5, 0, 6}, // 3
	{0, 0, 0, 0, 0, 0, 5, 0, 0, 0}, // 4
	{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // 5
	{0, 0, 0, 0, 5, 0, 0, 0, 0, 0}, // 6
	{0, 4, 0, 5, 0, 0, 0, 0, 0, 8}, // 7
	{0, 0, 5, 0, 0, 0, 0, 0, 0, 0}, // 8
	{0, 5, 0, 6, 0, 0, 0, 8, 0, 0}, // 9
}

var M, N int

func numberOfPatterns(m, n int) int {
	M = m
	N = n
	var work = make([]bool, 10, 10)
	return count(work, 0, 0)
}

func count(work []bool, now int, already int) (res int) {
	if already >= M && already <= N {
		res++
	} else if already > N {
		return
	}
	for i, tmp := 1, 0; i != 10; i++ {
		if work[i] { // if already visited
			continue
		}
		tmp = blocker[now][i]
		if tmp == 0 || work[tmp] {
			work[i] = true
			already++
			res += count(work, i, already)
			already--
			work[i] = false
		}
	}
	return
}