2021-11-22每日刷题打卡

2021-11-22每日刷题打卡

力扣——每日一题

384. 打乱数组

给你一个整数数组 nums ，设计算法来打乱一个没有重复元素的数组。

实现 Solution class:

Solution(int[] nums) 使用整数数组 nums 初始化对象
int[] reset() 重设数组到它的初始状态并返回
int[] shuffle() 返回数组随机打乱后的结果

示例：

输入
[“Solution”, “shuffle”, “reset”, “shuffle”]
[[[1, 2, 3]], [], [], []]
输出
[null, [3, 1, 2], [1, 2, 3], [1, 3, 2]]

解释
Solution solution = new Solution([1, 2, 3]);
solution.shuffle(); // 打乱数组 [1,2,3] 并返回结果。任何 [1,2,3]的排列返回的概率应该相同。例如，返回 [3, 1, 2]
solution.reset(); // 重设数组到它的初始状态 [1, 2, 3] 。返回 [1, 2, 3]
solution.shuffle(); // 随机返回数组 [1, 2, 3] 打乱后的结果。例如，返回 [1, 3, 2]

不知道这题有什么意义，但这次学到了个叫做洗牌算法的东西，就是随机的打乱一个数组，每次打乱的地方都不一样。

这个洗牌算法就是，for循环从下标0开始遍历，生成一个随机数，范围是0~数组长度内，然后每次把下标为i的元素和下标为随机数的元素交换，这样就是随机打乱了数组，把数组遍历完后得到的就是随机打乱的数组了，因为随机数生成每个数的概率都是一样的，所以打乱的也是随机的不会有换了好几次结果都是一样的情况发生。

class Solution {
public:
    vector<int>v;
    vector<int>v1;
    Solution(vector<int>& nums) {
        v=nums;
        v1=nums;
    }
    
    vector<int> reset() {
        v=v1;
        return v;
    }
    
    vector<int> shuffle() {
        int n=v.size();
        for(int i=0;i<n;i++)
        {
            int a=(i+rand()%n)%n;
            int temp=v[a];
            v[a]=v[i];
            v[i]=temp;
        }
        return v;
    }
};

/**
 * Your Solution object will be instantiated and called as such:
 * Solution* obj = new Solution(nums);
 * vector<int> param_1 = obj->reset();
 * vector<int> param_2 = obj->shuffle();
 */

151. 翻转字符串里的单词

给你一个字符串 s ，逐个翻转字符串中的所有 单词 。

单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。

请你返回一个翻转 s 中单词顺序并用单个空格相连的字符串。

说明：

输入字符串 s 可以在前面、后面或者单词间包含多余的空格。
翻转后单词间应当仅用一个空格分隔。
翻转后的字符串中不应包含额外的空格。

示例 1：

输入：s = “the sky is blue”
输出：“blue is sky the”

先把字符串整个翻转过来，然后遍历字符串，用双指针遍历找到一个单词的头和尾，然后把这个单词调转过来，然后继续找下一个单词，循环下去即可。

class Solution {
public:
    string reverseWords(string s) {
        int n=s.size(),l=0,r=n-1,idx=0;
        reverse(s.begin(),s.end());
        for(int i=0;i<n;i++)
        {
            if(s[i]!=' ')
            {
                if(idx)s[idx++]=' ';
                int end=i;
                while(end<n&&s[end]!=' ')s[idx++]=s[end++];
                reverse(s.begin()+idx-end+i,s.begin()+idx);
                i=end;
            }
        }
        s.erase(s.begin()+idx,s.end());
        return s;
    }
};

165. 比较版本号

给你两个版本号 version1 和 version2 ，请你比较它们。

版本号由一个或多个修订号组成，各修订号由一个 ‘.’ 连接。每个修订号由 多位数字 组成，可能包含 前导零 。每个版本号至少包含一个字符。修订号从左到右编号，下标从 0 开始，最左边的修订号下标为 0 ，下一个修订号下标为 1 ，以此类推。例如，2.5.33 和 0.1 都是有效的版本号。

比较版本号时，请按从左到右的顺序依次比较它们的修订号。比较修订号时，只需比较 忽略任何前导零后的整数值 。也就是说，修订号 1 和修订号 001 相等 。如果版本号没有指定某个下标处的修订号，则该修订号视为 0 。例如，版本 1.0 小于版本 1.1 ，因为它们下标为 0 的修订号相同，而下标为 1 的修订号分别为 0 和 1 ，0 < 1 。

返回规则如下：

如果 version1 > version2 返回 1，
如果 version1 < version2 返回 -1，
除此之外返回 0。

示例 1：

输入：version1 = “1.01”, version2 = “1.001”
输出：0
解释：忽略前导零，“01” 和 “001” 都表示相同的整数 “1”

我们把版本号以“.”为分界线拆开来，拆成一个个数字字符串，然后我们把字符串转成数字，依次和另一个字符串的数字进行对比，根据大小决定返回-1还是1还是0。

class Solution {
public:
    int compareVersion(string version1, string version2) {
    int l = 0, r = 0, n = version1.size(), m = version2.size();
    while(l<n||r<m)
    {
        int x=0;
        for(l;l<n;l++)
            if(version1[l]=='.')break;
            else x=x*10+version1[l]-'0';
        int y=0;
        for(r;r<m;r++)
            if(version2[r]=='.')break;
            else y=y*10+version2[r]-'0';
        r++,l++;
        if(x!=y)return x>y?1:-1;
    }
    return 0;
}
};

287. 寻找重复数

给定一个包含 n + 1 个整数的数组 nums ，其数字都在 1 到 n 之间（包括 1 和 n），可知至少存在一个重复的整数。

假设 nums 只有 一个重复的整数 ，找出 这个重复的数 。

你设计的解决方案必须不修改数组 nums 且只用常量级 O(1) 的额外空间。

示例 1：

输入：nums = [1,3,4,2,2]
输出：2

这题和我们写的环状链表可以是一样的解法，也就是快慢指针，环状链表是当走到某一点时，他会回到之前遍历的点上，这里我们遍历数组也可以用类似的方式。

题目说了数字都在1~n之间，那我们每次可以用遍历到的数字来当我们的下标，循环以往，当出现重复数字的时候，我们就会出现在同一个地方，然后快指针回到开头开始和我们走一样的速度，第二次相遇的时候的那个数就是重复数字了。比如 1 3 4 2 2，l慢指针走一格到下标0，r快指针走两步先到0，然后根据nums[0]走到下标1，l走一步到下标1，r根据nums[1]走到下标3，再根据nums[3]走到2，然后l走到3，r先走到4再走到2，l再走走到2，r先走到4再走到2，此时l和r相等，把r放回原位1，l和r同时走，l到4、r到3，l到2、r到2.此时l和r第二次相遇了，相遇的这个2就是重复的数。

class Solution {
public:
    int findDuplicate(vector<int>& nums) {
        int l=0,n=nums.size(),r=n-1;
        while(l<n)
        {
            r=n-1;
            while(l<r)
                if(nums[l]==nums[r])return nums[l];
                else r--;
            l++;
        }
        return nums[l];
    }
};