22年34周

目录

一：有效的字母异位词

二：两个数组的交集

三：快乐数

四：两数之和

---

一：有效的字母异位词

题目链接：有效的字母异位词

思路：就是典型哈希表的题，遍历第一字符串，之后再遍历第二个字符串

//利用切片
func isAnagram(s string, t string) bool {

    hashTable := make([]int,26)

    if len(s) != len(t) {
        return false
    }

    for _,v := range s {
        hashTable[v-'a'] += 1//每次进行加1
    }

    for _,v := range t {
        hashTable[v-'a'] -= 1//每次进行加1
    }

    for _,v := range hashTable {
        if v != 0 {
            return false
        }
    }

    return true

}


//利用数组
func isAnagram(s string, t string) bool {
    record := [26]int{}
    for _, r := range s {
        record[r-rune('a')]++
    }
    for _, r := range t {
        record[r-rune('a')]--
    }

    return record == [26]int{}
}

二：两个数组的交集

链接： 两个数组的交集

func intersection(nums1 []int, nums2 []int) []int {

    hashTable := make(map[int]int)

    for _,v := range nums1 {
        hashTable[v]++
    }

    result := make([]int,0)

    for _,v := range nums2 {
        if hashTable[v] != 0 {
            result = append(result,v)
            hashTable[v] = 0
        }
    }

    return result
}

三：快乐数

链接：快乐数

思路：用一个hash表存储可能会重复出现的和

func isHappy(n int) bool {

    hashTable := make(map[int]int)

    res := 0

    for res != 1 {
        res = 0
        for n != 0 {
            remainder := n % 10
            res += remainder * remainder
            n = n / 10  
        }
        n = res
        if hashTable[res] == 1 {
            return false
        }
        hashTable[res] = 1
    }

    return true
}

四：两数之和

链接：两数之和

思路：用一个hash表把差值到下标的映射存储起来，之后边计算差值，边进行hash查找

func twoSum(nums []int, target int) []int {

    hashTable := make(map[int]int)//差值--》下标的映射，其中0的value替换为-1，防止和默认值重复

    res := make([]int,2)

    for k,v := range nums {
        if hashTable[v] != 0 {
            if hashTable[v] == -1 {
                return []int{0,k}
            }
            res[0] = hashTable[v]
            res[1] = k
            return res
        }
        if k == 0 {
            hashTable[target - v] = -1
        }else {
            hashTable[target - v] = k
        }
    }

    return []int{0,0}
}


//简洁写法
func twoSum(nums []int, target int) []int {
    m := make(map[int]int)
    for index, val := range nums {
        if preIndex, ok := m[target-val]; ok {
            return []int{preIndex, index}
        } else {
            m[val] = index
        }
    }
    return []int{}
}