func twoSum(nums []int, target int) []int {
    left := 0
    for left < len(nums) {
        right := left + 1
        for right < len(nums) {
            if nums[left] + nums[right] == target {
                return []int{left, right}
            }
            right++
        }
        left++
    }
    return []int{}
}

func twoSum(nums []int, target int) []int {
    hashMap := make(map[int]int)
    for i := 0; i < len(nums); i++ {
        wanted := target - nums[i]
        if index, ok := hashMap[wanted]; ok {
            return []int{index, i}
        }
        hashMap[nums[i]] = i
    }
    return nil
}

func groupAnagrams(strs []string) [][]string {
    var ans [][]string
    hashMap := make(map[string][]string)

    for _, str := range strs {
        s := []byte(str)
        sort.Slice(s, func(i, j int) bool { return s[i] < s[j] })
        sortedStr := string(s)
        hashMap[sortedStr] = append(hashMap[sortedStr], str)

    }
    for _, part := range hashMap {
        ans = append(ans, part)
    }
    return ans
}

func groupAnagrams(strs []string) [][]string {
    hashMap := make(map[[26]int][]string)
    for _, str := range strs {
        cnt := [26]int{}
        for _, b := range str {
            cnt[b-'a']++
        }
        hashMap[cnt] = append(hashMap[cnt], str)
    }
    var ans [][]string
    for _, v := range hashMap {
        ans = append(ans, v)
    }
    return ans
}

func longestConsecutive(nums []int) int {
    sort.Slice(nums, func(i, j int) bool { return nums[i] < nums[j] })
    cur := 1
      maxNum := 1
      if len(nums) == 0 {
        return 0
    }
    if len(nums) == 1 {
        return 1
    }

    pre := nums[0]
    for i := 1; i < len(nums); i++ {
        if nums[i] == pre {
            continue
        }
        if nums[i] == pre + 1 {
            cur++
        } else if nums[i] > pre + 1 {
            maxNum = max(cur, maxNum)
            cur = 1
        }
        pre = nums[i]
    }
    return max(maxNum, cur)
}

func longestConsecutive(nums []int) int {
    numSet := make(map[int]bool)
    for _, num := range nums {
        numSet[num] = true
    }
    longestStreak := 0
    for num := range numSet {
        if !numSet[num - 1] {
            currentNum := num
            currentStreak := 1
            for numSet[currentNum + 1] {
                currentNum++
                currentStreak++
            }
            if longestStreak < currentStreak {
                longestStreak = currentStreak
            }
        }
    }
    return longestStreak
}

func moveZeroes(nums []int) {
    left := 0

    for right := 0; right < len(nums); right++ {
        if nums[right] != 0 {
            nums[left], nums[right] = nums[right], nums[left]
            left++
        }
    }
}