leetcode数组刷题-C++

首先，新手朋友没有学过类不要紧，只需要记得里面写你的代码就行了，里面的就当普通函数用
代码中写了网址和题目，方便查看，会持续更新

#include<iostream>
#include<string>
#include<vector>
#include <cstdlib>
#include<algorithm>
using namespace std;
class Solution1 {
public:
    //小A 和 小B 在玩猜数字。小B 每次从 1, 2, 3 中随机选择一个，小A 每次也从 1, 2, 3 中选择一个猜。
    // 他们一共进行三次这个游戏，请返回 小A 猜对了几次？
    //输入的guess数组为 小A 每次的猜测，answer数组为 小B 每次的选择。guess和answer的长度都等于3。
    //https://leetcode.cn/problems/guess-numbers/submissions/627175122/?envType=problem-list-v2&envId=array
    int game(vector<int>& guess, vector<int>& answer) 
    {
        int sum = 0;
        for (int i = 0; i < 3; i++)
        {
            if (guess[i] == answer[i])
            {
                sum++;
            }
        }
        return sum;
    }
};
class Solution2 {
public:
    int minCount(vector<int>& coins)
    {
       /* 桌上有 n 堆力扣币，每堆的数量保存在数组 coins 中。我们每次可以选择任意一堆，拿走其中的一枚或者两枚，求拿完所有力扣币的最少次数。

            示例 1：

            输入：[4, 2, 1]

            输出：4

            解释：第一堆力扣币最少需要拿 2 次，第二堆最少需要拿 1 次，第三堆最少需要拿 1 次，总共 4 次即可拿完。*/
        //https://leetcode.cn/problems/na-ying-bi/description/?envType=problem-list-v2&envId=array
        int sum = 0;
        for (int i = 0; i < coins.size(); i++)
        {
            sum += coins[i] / 2 + coins[i] % 2;
        }
        return sum;
    }
};
class Solution3 {
public:
    int smallestEqual(vector<int>& nums) 
    {
        /*给你一个下标从 0 开始的整数数组 nums ，返回 nums 中满足 i mod 10 == nums[i] 的最小下标 i ；如果不存在这样的下标，返回 - 1 。

            x mod y 表示 x 除以 y 的 余数 。

            示例 1：
            输入：nums = [0, 1, 2]
            输出：0
            解释：
            i = 0: 0 mod 10 = 0 == nums[0].
            i = 1 : 1 mod 10 = 1 == nums[1].
            i = 2 : 2 mod 10 = 2 == nums[2].
            所有下标都满足 i mod 10 == nums[i] ，所以返回最小下标 0*/
        for (int i = 0; i < nums.size(); i++)
        {
            if (i % 10 == nums[i])return i;//简单模拟
        }
        return -1;
    }
};
class Solution4 {
public:
    int findMaxConsecutiveOnes(vector<int>& nums) 
    {
        /*给定一个二进制数组 nums ， 计算其中最大连续 1 的个数。

            示例 1：

            输入：nums = [1, 1, 0, 1, 1, 1]
            输出：3
            解释：开头的两位和最后的三位都是连续 1 ，所以最大连续 1 的个数是 3.*/
        //https://leetcode.cn/problems/max-consecutive-ones/description/?envType=problem-list-v2&envId=array
        int flag=0;
        int temp = 0;
        for (int i = 0; i < nums.size(); i++)
        {
            if (nums[i] == 1)
            {
                flag++; 
                if (flag > temp)temp = flag;
            }
            else flag = 0;
        }
        return temp;
    }
};
class Solution5 {
public:
    int countKDifference(vector<int>& nums, int k) 
    {
       /* 给你一个整数数组 nums 和一个整数 k ，请你返回数对(i, j) 的数目，满足 i < j 且 | nums[i] - nums[j]| == k 。

            | x | 的值定义为：

            如果 x >= 0 ，那么值为 x 。
            如果 x < 0 ，那么值为 - x 。


            示例 1：

            输入：nums = [1, 2, 2, 1], k = 1
            输出：4
            解释：差的绝对值为 1 的数对为：
            - [1, 2, 2, 1]
            - [1, 2, 2, 1]
            - [1, 2, 2, 1]
            - [1, 2, 2, 1]*/
        //https://leetcode.cn/problems/count-number-of-pairs-with-absolute-difference-k/description/?envType=problem-list-v2&envId=array
        int sum = 0;
        for (int i = 0; i < nums.size(); i++)
        {
            for (int j = i + 1; j < nums.size(); j++)
            {
                if (abs(nums[i] - nums[j]) == k) sum++;//abs是绝对值函数
            }
        }
        return sum;
    }
};
class Solution6 {
public:
    int maxProduct(vector<int>& nums) 
    {
        /*给你一个整数数组 nums，请你选择数组的两个不同下标 i 和 j，使(nums[i] - 1)* (nums[j] - 1) 取得最大值。

            请你计算并返回该式的最大值。



            示例 1：

            输入：nums = [3, 4, 5, 2]
            输出：12
            解释：如果选择下标 i = 1 和 j = 2（下标从 0 开始），则可以获得最大值，
            (nums[1] - 1) * (nums[2] - 1) = (4 - 1) * (5 - 1) = 3 * 4 = 12 。*/
        //https://leetcode.cn/problems/maximum-product-of-two-elements-in-an-array/description/?envType=problem-list-v2&envId=array
        /*int maxNum = 0;//最终目标
        int temp = 0;
        for (int i = 0; i < nums.size(); i++)
        {
            for (int j = i + 1; j < nums.size(); j++)
            {
                temp = (nums[i] - 1) * (nums[j] - 1);
                if (temp > maxNum)maxNum = temp;
            }
        }
        return maxNum;*/

        //上述的方法很低效，需要全部便利
        sort(nums.begin(), nums.end());
        return (nums.back() - 1) * (nums[nums.size() - 2] - 1);
    }
};
class Solution7 {
public:
    int differenceOfSum(vector<int>& nums)
    {
        /*给你一个正整数数组 nums 。

            元素和 是 nums 中的所有元素相加求和。
            数字和 是 nums 中每一个元素的每一数位（重复数位需多次求和）相加求和。
            返回 元素和 与 数字和 的绝对差。

            注意：两个整数 x 和 y 的绝对差定义为 | x - y | 。



            示例 1：

            输入：nums = [1, 15, 6, 3]
            输出：9
            解释：
            nums 的元素和是 1 + 15 + 6 + 3 = 25 。
            nums 的数字和是 1 + 1 + 5 + 6 + 3 = 16 。
            元素和与数字和的绝对差是 | 25 - 16 | = 9 。
            1 <= nums.length <= 2000
            1 <= nums[i] <= 2000
            */

            //https://leetcode.cn/problems/difference-between-element-sum-and-digit-sum-of-an-array/description/?envType=problem-list-v2&envId=array

            //本体并不难，只是看起来比前面的复杂了，实际每一步都很简单，重点在于如何求每一个数的位数
        int sumEle = 0;//元素和
        int sumDigit = 0;//位数和
        for (int i = 0; i < nums.size(); i++)
        {
            sumEle += nums[i];
            int temp = nums[i];//使用临时变量，不修改数组本身的值
            while (temp > 0)
            {
                sumDigit += temp% 10;
                temp/= 10;
            }
        } 
        return abs(sumEle - sumDigit);
    }
};
class Solution8 {
public:
    int maximizeSum(vector<int>& nums, int k)
    {
        //2656 k个元素的最大和
       /* 给你一个下标从 0 开始的整数数组 nums 和一个整数 k 。你需要执行以下操作 恰好 k 次，最大化你的得分：

            从 nums 中选择一个元素 m 。
            将选中的元素 m 从数组中删除。
            将新元素 m + 1 添加到数组中。
            你的得分增加 m 。
            请你返回执行以上操作恰好 k 次后的最大得分。



            示例 1：

            输入：nums = [1, 2, 3, 4, 5], k = 3
            输出：18
            解释：我们需要从 nums 中恰好选择 3 个元素并最大化得分。
            第一次选择 5 。和为 5 ，nums = [1, 2, 3, 4, 6] 。
            第二次选择 6 。和为 6 ，nums = [1, 2, 3, 4, 7] 。
            第三次选择 7 。和为 5 + 6 + 7 = 18 ，nums = [1, 2, 3, 4, 8] 。
            所以我们返回 18 。
            18 是可以得到的最大答案。*/
        //毫无疑问，需要我们进行挑最大的来进行  max_element

        //继续思考，我们把最大的拿出来，又放进去一个更大的，那么永远就是这个位置的最大的，并且每次都是+1

        auto max = max_element(nums.begin(), nums.end());//此时获取的是迭代器，需要解引用
        
        //因为每次都是基础+1

        int temp = 1;
        int sum = *max*k;//*max是解引用
        for (int i = 1; i < k; i++)//因为第一次都是直接拿，所以少循环一次
        {
            sum += temp;
            temp++;
        }  
        return sum;
    }
};
class Solution9 {
public:
    int arithmeticTriplets(vector<int>& nums, int diff) 
    {
        //2367. 等差三元组的数目
       /* 给你一个下标从 0 开始、严格递增 的整数数组 nums 和一个正整数 diff 。如果满足下述全部条件，则三元组(i, j, k) 就是一个 等差三元组 ：

            i < j < k ，
            nums[j] - nums[i] == diff 且
            nums[k] - nums[j] == diff
            返回不同 等差三元组 的数目。



            示例 1：

            输入：nums = [0, 1, 4, 6, 7, 10], diff = 3
            输出：2
            解释：
            (1, 2, 4) 是等差三元组：7 - 4 == 3 且 4 - 1 == 3 。
            (2, 4, 5) 是等差三元组：10 - 7 == 3 且 7 - 4 == 3 。
            3 <= nums.length <= 200
            0 <= nums[i] <= 200
            1 <= diff <= 50
            nums 严格 递增*/
        
        //其实也就是说，找三个数，满足等差数列,等差就是diff
         // 最简单办法就是什么呢，三指针
        int ans = 0;//计数用的
        for (int i = 0, j = 1, k = 2; i < nums.size() - 2&&j < nums.size() - 1&& k < nums.size(); i++)
        {
            j = max(j, i + 1);
            while (j < nums.size() - 1 && nums[j] - nums[i] < diff)
            {
                j++;
            }
            if (j >= nums.size() - 1 || nums[j] - nums[i] > diff)
            {
                continue;
            }
            k = max(k, j + 1);
            while (k < nums.size() && nums[k] - nums[j] < diff)
            {
                k++;
            }
            if(k >= nums.size() || nums[k] - nums[j] > diff)
            {
                continue;
            }
            if (k < nums.size() && nums[k] - nums[j] == diff)
            {
                ans++;
            }
           
        }
         return ans;
    }
};
class Solution10 {
public:
    int removeElement(vector<int>& nums, int val)
    {
        //27 移除元素
       /* 给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素。元素的顺序可能发生改变。然后返回 nums 中与 val 不同的元素的数量。

            假设 nums 中不等于 val 的元素数量为 k，要通过此题，您需要执行以下操作：

            更改 nums 数组，使 nums 的前 k 个元素包含不等于 val 的元素。nums 的其余元素和 nums 的大小并不重要。
            返回 k。
            示例 1：

            输入：nums = [3, 2, 2, 3], val = 3
            输出：2, nums = [2, 2, _, _]
            解释：你的函数函数应该返回 k = 2, 并且 nums 中的前两个元素均为 2。
                你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。*/
        /*示例 2：

            输入：nums = [0, 1, 2, 2, 3, 0, 4, 2], val = 2
            输出：5, nums = [0, 1, 4, 0, 3, _, _, _]
            解释：你的函数应该返回 k = 5，并且 nums 中的前五个元素为 0, 0, 1, 3, 4。
                注意这五个元素可以任意顺序返回。
                你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。*/

        //本题我们可以看到，他是引用的方式传递进来，意味着我们修改了这个数组，外部的数组也会改变，那么我们看评测用例，这个我们发现只需要把非val
        //的值放前面，val的值放后面，内部进行一个交换就可以，那我们可以用一个方法，双指针，一个在前，一个在后
        //让左右指针往对向移动，左指针发现了是val就左右指针交换，然后右指针往前，左指针不动，左指针是不能动的以防交换的那个数也是val，右指针左移
        //如果不是val，左指针左移
        //最终我们需要返回非val的值，right指向最后一个元素，那么元素个数就是right+1
        //基本的考虑完成需要考虑特殊情况，如果传入的数组只有一个元素怎么办，我们发现此时left是等于right的
        //所以条件是left<=right
        int left = 0;
        int right = nums.size() - 1;
        while (left <= right)
        {
            if (nums[left] == val)
            {
                int temp = nums[left];
                nums[left] = nums[right];
                nums[right] = temp;
                right--;
            }
            else
            {
                left++;
            }
        }
        return right + 1;
    }
};
class Solution11 {
public:
    vector<int> buildArray(vector<int>& nums) 
    {
        //1920基于排列构建数组
        /*给你一个 从 0 开始的排列 nums（下标也从 0 开始）。请你构建一个 同样长度 的数组 ans ，其中，对于每个 i（0 <= i < nums.length），都满足 ans[i] = nums[nums[i]] 。返回构建好的数组 ans 。

            从 0 开始的排列 nums 是一个由 0 到 nums.length - 1（0 和 nums.length - 1 也包含在内）的不同整数组成的数组。



            示例 1：

            输入：nums = [0, 2, 1, 5, 3, 4]
            输出：[0, 1, 2, 4, 5, 3]
            解释：数组 ans 构建如下：
            ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4]], nums[nums[5]]]
            = [nums[0], nums[2], nums[1], nums[5], nums[3], nums[4]]
                = [0, 1, 2, 4, 5, 3]
            */
        //首先我们需要遍历一遍这个玩意,然后就按他说的来
        int n = nums.size();
        vector<int>v;
        for (int i = 0; i < n; i++)
        {
            int temp = nums[i];
            v.push_back(nums[temp]);
        }
        return v;

    }
};
int main()
{
    return 0;
}