【算法题】统计各位数字之和为偶数的整数个数、替换空格、旋转数组的最小数字

最新推荐文章于 2024-08-22 17:27:46 发布

Lion Long

最新推荐文章于 2024-08-22 17:27:46 发布

阅读量545

点赞数

分类专栏：数据结构与算法文章标签：算法

本文链接：https://blog.csdn.net/Long_xu/article/details/131386516

版权

数据结构与算法专栏收录该内容

28 篇文章 3 订阅

订阅专栏

算法题之数字处理

一、统计各位数字之和为偶数的整数个数
二、替换空格
- 2.1、题目
- 2.2、解题：遍历原地修改
三、旋转数组的最小数字
总结

一、统计各位数字之和为偶数的整数个数

1.1、题目

给你一个正整数 num ，请你统计并返回小于或等于 num 且各位数字之和为偶数的正整数的数目。

正整数的各位数字之和是其所有位上的对应数字相加的结果。

示例 1：

输入：num = 4
输出：2
解释：
只有 2 和 4 满足小于等于 4 且各位数字之和为偶数。

示例 2：

输入：num = 30
输出：14
解释：
只有 14 个整数满足小于等于 30 且各位数字之和为偶数，分别是：
2、4、6、8、11、13、15、17、19、20、22、24、26 和 28 。

来源：力扣（LeetCode）

1.2、理解题目

也就是给一个int型的整数num，统计大于0小于num范围内的满足要求的数字个数，这个数字的要求是其各位数字之和为偶数（比如10的个位数之和为1+0=1，不满足要求；13的个位数之和为1+3=4，满足要求）。

1.3、解题思路（暴力枚举）

首先想到的解题思路：

将num逐步减一（满足小于或等于 num要求），用一个循环对当前值的计算值取模和求余（，每次的取模得到的数（就是各位数）相加，直到求余得到的数为0时退出循环，然后判断取模得到的数（就是各位数）相加是否为偶数。

代码：

class Solution {
public:
    int countEven(int num) {
        int count=0;//统计数量
        while(num>1)// 判断
        {
            int pre=num;// 保存要计算的数值
            int cur=0; // 记录
            while(pre)
            {
                cur+=pre%10;//取模并相加
                pre/=10;//取余
            }
            if(cur%2==0)//偶数
                count++;//统计
            num--;//递减
        }
        return count;
    }
};

测试结果：

执行用时：0 ms, 在所有 C++ 提交中击败了100.00%的用户
内存消耗：5.8 MB, 在所有 C++ 提交中击败了40.59%的用户
通过测试用例：71 / 71

时间复杂度： O(n log n) 。

空间复杂度： O(1)。

1.4、解题思路2（数学公式）

首先，位于区间[0, 10)的奇数和偶数的个数都是5个。将 num表示为 10y+x的形式，其中 x大于等于0小于10且y大于等于0 ，那么位于区间 [0,num]的整数可以分为两个部分：区间[10y+0,10y+x]和区间[0,10y+0]
。

总结就是一个公式：将 num表示为10y+x，y=num/10，x=num%10；然后计算y的各个数之和是否为偶数，如果是偶数则结果为 y5+x/2+1 ，如果是奇数则结果为 y*5+(x+1)/2 。

上述区间中多计入了整数0，因此结果应该是位于上述区间且各位数字之和为偶数的个数减1。

class Solution {
public:
    int countEven(int num) {
        // num=10*y+x
        int y=num/10;
        int x=num%10;
        int res=y*5;
        int ysum=0;
        while(y)
        {
            ysum+=y%10;
            y=y/10;
        }
        if(ysum%2==0)
            res+=x/2+1;
        else
            res+=(x+1)/2;
        return res-1;
    }
};

测试结果：

执行用时：0 ms, 在所有 C++ 提交中击败了100.00%的用户
内存消耗：5.8 MB, 在所有 C++ 提交中击败了30.07%的用户

时间复杂度： O(log n)。

空间复杂度：O(1)。

1.5、小结

暴力枚举各位数之和的核心：

while(...){
    sum+=num%10;
    num/=10;
}

数学公式： num表示为10y+x ， y=num/10，x=num%10 。result=y5+(y的各位数之和是偶数吗)？(x/2+1) : (x(+1)/2) -1 。

二、替换空格

2.1、题目

实现一个函数，把字符串s中的每个空格替换成"%20"。

示例 1：

输入：s = “We are happy.”
输出：“We%20are%20happy.”
来源：力扣（LeetCode）

2.2、解题：遍历原地修改

在 C++ 语言中， string 被设计成「可变」的类型，因此可以在不新建字符串的情况下实现原地修改。

class Solution {
public:
    string replaceSpace(string s) {
        int len=s.length();
        string ret="";
        int i=0;
        while(i<len)
        {
            if(s[i]==' ')
                ret+="%20";
            else
                ret+=s[i];
            i++;
        }
        return ret;
    }
};

时间复杂度 O(N) 。

空间复杂度 O(1) 。

三、旋转数组的最小数字

3.1、题目

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。

给你一个可能存在重复元素值的数组 numbers ，它原来是一个升序排列的数组，并按上述情形进行了一次旋转。请返回旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一次旋转，该数组的最小值为 1。

注意，数组 [a[0], a[1], a[2], …, a[n-1]] 旋转一次的结果为数组 [a[n-1], a[0], a[1], a[2], …, a[n-2]] 。

示例 1：

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

示例 2：

输入：numbers = [2,2,2,0,1]
输出：0

来源：力扣（LeetCode）

3.2、思路

排序数组的查找问题首先考虑使用二分法解决，其可将遍历法的线性级别时间复杂度降低至对数级别。

在这里插入图片描述

二分法算法流程：

初始化：声明两个指针low、hight分别指向numbers的首元素和尾元素。
使用一个循环来二分，每次循环都计算中心位置inv=low+（hight-low）/2。
调整low和hight的位置：如果中心点inv位置的元素小于最高点hight位置的元素，则hight=inv；如果中心点inv位置的元素大于最高点hight位置的元素，则low=inv+1；否则hight=hight+1。
返回值：当low==hight时跳出二分循环，并返回旋转点的值 nums[low] 即可。

3.3、代码实现

class Solution {
public:
    int minArray(vector<int>& numbers) {
        int hight=numbers.size()-1;
        int low=0;
        while(low<hight)
        {
            int inv=low+(hight-low)/2;
            if(numbers[inv]>numbers[hight])
            {
                low=inv+1;
            }
            else if(numbers[inv]<numbers[hight])
            {
                hight=inv;
            }
            else
                hight-=1;
        }
        return numbers[low];

    }
};

时间复杂度 $O(log_2 N)$ ：在特例情况下（例如 [1, 1, 1, 1]），会退化到 O(N)。

空间复杂度 O(1) ：变量使用常数大小的额外空间。

当然，还有暴力枚举法，这种方法不建议。

class Solution {
public:
    int minArray(vector<int>& numbers) {
        int n=numbers.size();
        if(n==0)
            return 0;
            
        int res=numbers[0];
        for(int i=1;i<n;i++)
        {
            if(numbers[i]<numbers[i-1])
                return numbers[i];
        }
        return res;
    }
};