今天是day5：
题1：有效的字母异位词，要求两段等长的乱序字母中的字母完全一样：
法一：判断ascill码的数值大小，分别对s和t遍历，如果遍历结束后record中仍然位为空，说明确实存在字母相等

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 isAnagram(s string,t string) bool {
    if len(s) != len(t) {
        return false
    }
    records:=[26]int{}
    for index:=0;index<len(s);index++{
        if s[index] == t[index] {
            continue
        }
        scharindex := s[index] - 'a'
        records[scharindex]++
        tcharindex := t[index] - 'a'
        records[tchatindex]--
    }
    for _,record := range records{
        if record!=0 {
            return false
        }
    }
    return true
}

使用python，逻辑一致：

class Solution:
    def isAnagram(self,s:str,t:str) -> bool:
        record = [0] * 26
        for i in s:
            record[ord(i) -ord("a")] += 1
        for i in t:
            record[ord(i) - ord("a")] -=1
        for i in range(26):
            if record[i] != 0:
                return False
        return True

题目二：求两个数组的交集，即判断两个数组的交点并输出:
声明两个1001容量与长度的切片以及一个空数组，遍历nums1和nums2，把其中的唯一值作为下标值置为1，最后统一遍历两个切片，只要值相加为2，则说明有相同的值，并将下标保存在数组中可输出，在遍历中不断重复

func intersection(nums1 []int,nums2 []int) []int {
    count1 := make([]int,1001,1001)
    count2 := make([]int,1001,1001)
    res:=make([]int,0)
    for _,v := range nums1{
        count1[v] = 1
    }
    for _,v:= range nums2 {
        count2[v] = 1
    }
    for i:=0;i<=1000;i++ {
        if count1[i] + count2[i] == 2{
            res = append(res,i)
        }
    }
    return res
}

go集合法

func intersection(nums1 []int,nums2 []int) []int {
    set:=make(map[int]struct{},0)
    res:=make([]int,0)
    for _,v := range nums1{
        if _,ok:=set[v];!ok{
            set[v] = struct{}{}
        }
    }
    for _,v :=range nums2{
        if _,ok := set[v];ok{
            res = append(res,v)
            delete(set,v)
        }
    }
    return res

}

python中方法取两个：
法一逻辑同上：

class Solution:
    def intersection(self,nums1:List[int],nums2:List[int]) -> List[int]:
        count1 = [0] * 1001
        count2 = [0] * 1001
        result = []
        for i in range(len(nums1)):
            count1[nums1[i]] += 1
        for j in range(len(nums2)):
            count2[nums2[j]] += 1
        for k in range(1001):
            if count1[k] *count2[k] > 0:
                result.append[k]
        
        return result

法二为集合法：

class Solution:
    def intersection(self,nums1:List[int],nums2:List[int]) -> List[int]:
        return list(set(nums1) & set(nums2))

法3：

class Solution:
    def intersection(self,nums1:List[int],nums2:List[int]) -> List[int]:
        table = {}
        for num in nums1:
            table[num] = table.get(num,0) +1
        
        res = set()
        for num in nums2:
            if num in nums2:
                if num in table:
                    res.add(num)
                    del table[num]
        return list(res)

题目三:
快乐数，每一次将一个正整数替换为它每个数字上的值的平方和
go实现：

func isHappy(n int) bool {
    m:=make(map[int]bool)
    for n!= 1 && !m[n] {
        n,m[n] = getsum(n),true
    }
    return n == 1
}
func getsum(n int) int {
    sum:=0
    for n> 0{
        sum += (n % 10) * (n % 10)
        n = n / 10
    }
    return sum
}

python实现：

class Solution:
    def isHappy(self,n: int) -> bool:
        seen = set()
        while n != 1:
            n = sum(int(i) ** 2 for i in str(n))
            if n in seen:
                return False
            seen.add(n)
        return True

python法二：

class Solution:
    def isHappy(self,n: int) -> bool:
        seen = []
        while n != 1:
            n = sum(int(i) ** 2 for i in str(n))
            if n in seen:
                return False
            seen.append(n)
        return True

题目4：
两数之和，给定一个target，让你在数组中找到值相加等于这个target的下标并返回

func twosun(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{}
}

python版本：

class Solution:
    def twoSum(self,num:List[int],target:int) ->List[int]:
        for i in range(len(nums)):
            for j in range(i+1,len(nums)):
                if nums[i] + nums[j] == target:
                    return [i,j]