【leetcode】task3.查找1

搜索插入位置

int searchInsert(int* nums, int numsSize, int target){
    int a=0, b=numsSize-1, mid;
    while(a <= b){
        mid = (a + b) / 2;
        if(target > nums[mid])
            a = mid + 1;
        else if(target < nums[mid])
            b = mid - 1;
        else return mid;
    }
    return target<nums[mid] ? mid : mid + 1;
}

快乐数

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。如果 可以变为 1，那么这个数就是快乐数。

如果 n 是快乐数就返回 True ；不是，则返回 False 。

int count(int n){
int sum=0;
while(n>0){
    sum+=(n%10)*(n%10);
    n=n/10;
}
return sum;
}

bool isHappy(int n){
int fast=n;
int slow=n;
do{
    fast=count(fast);
    fast=count(fast);
    slow=count(slow);
}while(fast!=slow);
return slow==1;
}

题解：使用快慢指针来判断循环相等时刻，如果这时平方和为1了则为快乐数。

单词规律

给定一种规律 pattern 和一个字符串 str ，判断 str 是否遵循相同的规律。

这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连接的对应规律。

示例1:

输入: pattern = “abba”, str = “dog cat cat dog”
输出: true

class Solution:
    def wordPattern(self, pattern: str, str: str) -> bool:
        str=str.split(' ')
        return list(map(pattern.index,pattern))==list(map(str.index,str))

题解：把对应两个字符串中的内容判断转化为同一个东西，即相应的索引值(对于相同元素的索引值是相同的)

同构字符串

解题思路同单词规律。

class Solution:
    def isIsomorphic(self, s: str, t: str) -> bool:
        return list(map(s.index,s))==list(map(t.index,t));

有效的字母异位词

bool isAnagram(char * s, char * t){
int n=strlen(s);
int m=strlen(t);
if(n!=m) return false;

char a[26]={0};
for(int i=0;i<n;i++){
    a[s[i]-'a']++;
    a[t[i]-'a']--;
}
for(int j=0;j<m;j++){
    if(a[j]!=0) return false;
}
return true;
}

两个数组的交集

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

两个数组的交集II

题解：利用字典列出元素和数量，之后判断相同元素，按个数添加。

class Solution(object):
    def intersect(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: List[int]
        """
        from collections import Counter
        dic_num=Counter(nums1)
        res=[]
        for num in nums2:
            if dic_num[num]>0:
                res.append(num)
                dic_num[num]-=1
        return res

根据字符出现频率排序

给定一个字符串，请将字符串里的字符按照出现的频率降序排列。

示例 1:

输入:
“tree”

输出:
“eert”

class Solution:
    def frequencySort(self, s: str) -> str:
        from collections import Counter
        s_dict=Counter(s)
        s=sorted(s_dict.items(),key=lambda item:item[1],reverse=True)
        res=''
        for key,value in s:
            res+=key*value
        return res

题解：
Counter可以返回每种元素的数量，以字典的形式返回。之后使用sort对于数量这一项（设置对应key的值）进行降序排序。最后输出降序后的字符串。

有序数组中的单一元素

class Solution(object):
    def singleNonDuplicate(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        from collections import Counter
        dic_nums=Counter(nums)
        for key in dic_nums:
            if(dic_nums[key]==1):
                return key