代码随想录算法训练营第五天| 242.有效的字母异位词 ， 349. 两个数组的交集 ， 202. 快乐数 ， 1. 两数之和

242.有效的字母异位词 

繁冗版：

1，思路：

　　先建立两个map，对应两个字符串对应的字符，同时对他们进行计数，如果这两个数字相等，那么就是相等

2，代码

bool isAnagram_complicate(string s, string t) 
{
    unordered_map<char, int> existedCharBys;

    for (auto charItem : s)
    {
        if (existedCharBys.find(charItem) == existedCharBys.end())
        {
            existedCharBys.insert(make_pair(charItem, 0));
        }
        existedCharBys[charItem]++;
    }

    unordered_map<char, int> existedCharByt;

    for (auto charItem : t)
    {
        if (existedCharByt.find(charItem) == existedCharByt.end())
        {
            existedCharByt.insert(make_pair(charItem, 0));
        }
        existedCharByt[charItem]++;
    }
    
    // s > t
    if (existedCharBys.size() < existedCharByt.size())
    {
        swap(existedCharBys, existedCharByt);
    }

    for (auto Item : existedCharBys)
    {
        if (existedCharByt[Item.first] != Item.second)
        {
            return false;
        }
    }

    return true;
}

简单版：

1，思路：

　　因为一共有26个字母，所以只用定义一个26长度的数组，同时对一个是++，另一个是--，如果为0那么就是相等

2，代码：

bool isAnagram(string s, string t)
{
    int charItem[26] = {};

    // cahr 和 staring[i] 不同
    for (int i = 0; i < s.size(); i++) {
        charItem[s[i] - 'a']++;
    }
    for (int i = 0; i < t.size(); i++) {
        charItem[t[i] - 'a']--;
    }

    for (auto num : charItem)
    {
        if (num != 0)
        {
            return false;
        }
    }
    
    return true;
}

 

349. 两个数组的交集 

思路：

　　1，建立一个Set,如果另一个string中有这个set，那么就把值放到set中，同时使用

　　vector<int>(set.begin, set.end)进行插入

代码：

vector<int> intersection(vector<int>& nums1, vector<int>& nums2) 
{
    unordered_set<int> result;
    unordered_set<int> intersectSet;
    for (int num1 : nums1)
    {
        intersectSet.insert(num1);
    }

    for (int num2 : nums2)
    {
        if (intersectSet.find(num2) != intersectSet.end())
        {
            result.insert(num2);
        }
    }

    return vector<int>(result.begin(), result.end());
}

 

202. 快乐数 

难点：

1，怎么快速把一个数字找出来它的所有位数

2，怎么判断应该结束，当前状态处于无限循环中

代码：

数字-》打散成位数：

int getJudgeNum(int n)
{
    int result = 0;
    while (n != 0)
    {
        result += (n % 10) * (n % 10);
        n = n / 10;
    }

    return result;
}

判断快乐数

bool isHappy(int n)
{
    //先找出来 每一个位置的 数字
    unordered_set<int> selectedNum;
    while (1)
    {

        n = getJudgeNum(n);
        if (n == 1)
        {
            return true;
        }
        //注意循环的时候可能会相等
        if (selectedNum.find(n) != selectedNum.end())
        {
            return false;
        }
        selectedNum.insert(n);
    }

}

 1，两数之和

1，复杂：

vector<int> twoSum_complicate(vector<int>& nums, int target)
{
    unordered_multimap<int, int> quickSelected;
    vector<int> result;

    for (int i = 0; i < nums.size(); i++)
    {
        quickSelected.insert(make_pair(nums[i], i));
    }

    for (int i = 0; i < nums.size(); i++)
    {
        auto targetPair = quickSelected.find(target - nums[i]);
        if (targetPair != quickSelected.end() && targetPair->second !=i)
        {
            result.push_back(i);
            result.push_back(targetPair->second);
            return result;
        }
    }

    return result;
}

2，简单

vector<int> twoSum(vector<int>& nums, int target)
{
    unordered_multimap<int, int> quickSelected;
    vector<int> result;

    for (int i = 0; i < nums.size(); i++)
    {
        auto targetPair = quickSelected.find(target - nums[i]);
        if (targetPair != quickSelected.end())
        {
            return vector<int>{i, targetPair->second};
        }

        quickSelected.insert(make_pair(nums[i], i));
    }

    return result;
}