力扣C++｜一题多解之数学题专场（1）

最新推荐文章于 2024-11-27 19:38:10 发布
原创 最新推荐文章于 2024-11-27 19:38:10 发布 · 1.9k 阅读 · 79 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #leetcode

本文提供了四类整数操作的C++解决方案：整数反转、判断回文数、整数转罗马数字和罗马数字转整数，以及两数相除的无乘除法算法。每种操作都有多种解法，如反转整数通过比较反转后的大小防止溢出，回文数判断通过比较原数和反转后的数等。

 

目录

7. 整数反转

9. 回文数

12. 整数转罗马数字

13. 罗马数字转整数

29. 两数相除

7. 整数反转

给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。

-如果反转后整数超过 32 位的有符号整数的范围 [2^31, 2^31 -1] ，就返回 0。

假设环境不允许存储 64 位整数（有符号或无符号）。

示例 1：

输入：x = 123
输出：321

示例 2：

输入：x = -123
输出：-321

示例 3：

输入：x = 120
输出：21

示例 4：

输入：x = 0
输出：0

提示：

  • -2^31 <= x <= 2^31 - 1

解法1： 

#include <bits/stdc++.h>
using namespace std;

class Solution
{
public:
    int reverse(int x)
    {
        int MAX = 0x7fffffff;
        int MIN = 1 << 31;
        ostringstream stream, smax, smin;
        string ss;
        stream << x;
        ss += stream.str();
        smax << MAX;
        string max_num = smax.str();
        smin << MIN;
        string min_num = smin.str();
        std::reverse(ss.begin(), ss.end());
        if (x < 0)
        {
            ss.insert(0, "-");
            ss.pop_back();
        }
        if (x > 0 && ss.size() >= max_num.size() && (ss > max_num))
            return 0;
        else if (x < 0 && ss.size() >= min_num.size() && ss > min_num)
            return 0;
        else
            return atoi(ss.c_str());
    }
};

int main()
{
	Solution s;
	vector<int> nums = {123,-123,120,0};
	
	for(auto num:nums)
		cout << s.reverse(num) << endl;

	return 0;
}

解法2：  

#include <bits/stdc++.h>
using namespace std;

class Solution
{
public:
#define INT_MAX 2147483647
#define INT_MIN (-INT_MAX - 1)
    int reverse(int x)
    {
        int flag = x < 0 ? -1 : 1;
        int num = 0;
        while (x)
        {
            if ((flag == -1 && (INT_MIN / 10 > num)) || (flag == 1 && INT_MAX / 10 < num))
                return 0;
            num = num * 10 + x % 10;
            x /= 10;
        }
        return num;
    }
};

int main()
{
	Solution s;
	vector<int> nums = {123,-123,120,0};
	
	for(auto num:nums)
		cout << s.reverse(num) << endl;

	return 0;
}

解法3：  

#include <bits/stdc++.h>
using namespace std;

class Solution
{
public:
    int reverse(int x)
    {
        int rev = 0;
        while (x != 0)
        {
            int pop = x % 10;
            x = x / 10;
            if (rev > INT_MAX / 10 || (rev == INT_MAX / 10 && pop > 7))
                return 0;
            if (rev < INT_MIN / 10 || (rev == INT_MIN / 10 && pop < -8))
                return 0;
            rev = rev * 10 + pop;
        }
        return rev;
    }
};

int main()
{
	Solution s;
	vector<int> nums = {123,-123,120,0};
	
	for(auto num:nums)
		cout << s.reverse(num) << endl;

	return 0;
}

9. 回文数

给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。

回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，121 是回文，而 123 不是。

示例 1：

输入：x = 121
输出：true

示例 2：

输入：x = -121
输出：false
解释：从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。

示例 3：

输入：x = 10
输出：false
解释：从右向左读, 为 01 。因此它不是一个回文数。

示例 4：

输入：x = -101
输出：false

提示：

  • -2^31 <= x <= 2^31 - 1

进阶：你能不将整数转为字符串来解决这个问题吗？

解法1： 

#include <bits/stdc++.h>
using namespace std;

class Solution
{
public:
    bool isPalindrome(long int x)
    {
        long int rev;
        if (x < 0)
            return false;
        string str_x = to_string(x);
        std::reverse(str_x.begin(), str_x.end());
        stringstream out(str_x);
        out >> rev;
        return x == rev;
    }
};

int main()
{
	Solution s;
	vector<int> nums = {121,-121,10,-101};
	
	for(auto num:nums)
		cout << s.isPalindrome(num) << endl;

	return 0;
}

解法2：  

#include <bits/stdc++.h>
using namespace std;

class Solution
{
public:
    bool isPalindrome(long int x)
    {
        long int midrev = 0;
        if (x < 0 || (x % 10 == 0 && x != 0))
            return false;
        while (x > midrev)
        {
            midrev = midrev * 10 + x % 10;
            x /= 10;
        }
        return midrev == x || midrev / 10 == x;
    }
};

int main()
{
	Solution s;
	vector<int> nums = {121,-121,10,-101};
	
	for(auto num:nums)
		cout << s.isPalindrome(num) << endl;

	return 0;
}

解法3：  

#include <bits/stdc++.h>
using namespace std;

class Solution {
public:
    bool isPalindrome(long int x) {
       if (x < 0) return false;
       long int sum = 0, t = x;
       while(x) 
       {
           sum = sum * 10 + x % 10;
           x /= 10;
       }
       return t == sum;
    }
};

int main()
{
	Solution s;
	vector<int> nums = {121,-121,10,-101};
	
	for(auto num:nums)
		cout << s.isPalindrome(num) << endl;

	return 0;
}

12. 整数转罗马数字

罗马数字包含以下七种字符： I， V， X， L，C，D 和 M。

字符          数值
I             1
V             5
X             10
L             50
C             100
D             500
M             1000

例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做  XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

  • I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
  • X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。 
  • C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。

给你一个整数，将其转为罗马数字。

示例 1:

输入: num = 3
输出: "III"

示例 2:

输入: num = 4
输出: "IV"

示例 3:

输入: num = 9
输出: "IX"

示例 4:

输入: num = 58
输出: "LVIII"
解释: L = 50, V = 5, III = 3.

示例 5:

输入: num = 1994
输出: "MCMXCIV"
解释: M = 1000, CM = 900, XC = 90, IV = 4.

提示：

  • 1 <= num <= 3999

解法1：  

#include <bits/stdc++.h>
using namespace std;

class Solution
{
public:
    string getNum1000(int num1000)
    {
        if (num1000 == 3)
        {
            return "MMM";
        }
        else if (num1000 == 2)
        {
            return "MM";
        }
        else if (num1000 == 1)
        {
            return "M";
        }
        else
        {
            return "";
        }
    }

    string getNum100(int num100)
    {

        switch (num100)
        {
        case 1:
            return "C";
        case 2:
            return "CC";
        case 3:
            return "CCC";
        case 4:
            return "CD";
        case 5:
            return "D";
        case 6:
            return "DC";
        case 7:
            return "DCC";
        case 8:
            return "DCCC";
        case 9:
            return "CM";
        default:
            return "";
        }
    }

    string getNum10(int num10)
    {

        switch (num10)
        {
        case 1:
            return "X";
        case 2:
            return "XX";
        case 3:
            return "XXX";
        case 4:
            return "XL";
        case 5:
            return "L";
        case 6:
            return "LX";
        case 7:
            return "LXX";
        case 8:
            return "LXXX";
        case 9:
            return "XC";
        default:
            return "";
        }
    }

    string getNum1(int num1)
    {
        switch (num1)
        {
        case 1:
            return "I";
        case 2:
            return "II";
        case 3:
            return "III";
        case 4:
            return "IV";
        case 5:
            return "V";
        case 6:
            return "VI";
        case 7:
            return "VII";
        case 8:
            return "VIII";
        case 9:
            return "IX";
        default:
            return "";
        }
    }

    string intToRoman(int num)
    {
        int num1000 = num / 1000;
        int num100 = (num % 1000) / 100;
        int num10 = (num % 100) / 10;
        int num1 = (num % 10);
        string res;
        res = getNum1000(num1000) + getNum100(num100) + getNum10(num10) + getNum1(num1);
        return res;
    }
};

int main()
{
	Solution s;
	vector<int> nums = {3,4,9,58,1994};
	
	for(auto num:nums)
		cout << s.intToRoman(num) << endl;

	return 0;
}

解法2：  

#include <bits/stdc++.h>
using namespace std;

class Solution
{
public:
    string intToRoman(int num)
    {
        int values[13] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
        string reps[13] = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
        string res;
        for (int i = 0; i < 13; i++)
        {
            while (num >= values[i])
            {
                num -= values[i];
                res += reps[i];
            }
        }
        return res;
    }
};

int main()
{
	Solution s;
	vector<int> nums = {3,4,9,58,1994};
	
	for(auto num:nums)
		cout << s.intToRoman(num) << endl;

	return 0;
}

解法3：  

#include <bits/stdc++.h>
using namespace std;

class Solution
{
public:
    string intToRoman(int num)
    {
        string bit1[10] = {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
        string bit10[10] = {"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"};
        string bit100[10] = {"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"};
        string bit1000[4] = {"", "M", "MM", "MMM"};
        return bit1000[num / 1000] + bit100[num % 1000 / 100] + bit10[num % 100 / 10] + bit1[num % 10];
    }
};

int main()
{
	Solution s;
	vector<int> nums = {3,4,9,58,1994};
	
	for(auto num:nums)
		cout << s.intToRoman(num) << endl;

	return 0;
}

13. 罗马数字转整数

罗马数字包含以下七种字符： I， V， X， L，C，D 和 M。

字符          数值
I             1
V             5
X             10
L             50
C             100
D             500
M             1000

例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做  XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

  • I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
  • X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。 
  • C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。

给你一个整数，将其转为罗马数字。

示例 1:

输入: num = 3
输出: "III"

示例 2:

输入: num = 4
输出: "IV"

示例 3:

输入: num = 9
输出: "IX"

示例 4:

输入: num = 58
输出: "LVIII"
解释: L = 50, V = 5, III = 3.

示例 5:

输入: num = 1994
输出: "MCMXCIV"
解释: M = 1000, CM = 900, XC = 90, IV = 4.

提示：

  • 1 <= num <= 3999

解法1：  

#include <bits/stdc++.h>
using namespace std;

class Solution
{
public:
    int romanToInt(string s)
    {
        int sum = 0;
        for (int i = 1; i <= s.size(); i++)
        {
            if (s[i - 1] == 'I' && s[i] == 'V')
            {
                sum += 4;
                i++;
            }
            else if (s[i - 1] == 'I' && s[i] == 'X')
            {
                sum += 9;
                i++;
            }
            else if (s[i - 1] == 'X' && s[i] == 'L')
            {
                sum += 40;
                i++;
            }
            else if (s[i - 1] == 'X' && s[i] == 'C')
            {
                sum += 90;
                i++;
            }
            else if (s[i - 1] == 'C' && s[i] == 'D')
            {
                sum += 400;
                i++;
            }
            else if (s[i - 1] == 'C' && s[i] == 'M')
            {
                sum += 900;
                i++;
            }
            else if (s[i - 1] == 'I')
            {
                sum += 1;
            }
            else if (s[i - 1] == 'V')
            {
                sum += 5;
            }
            else if (s[i - 1] == 'X')
            {
                sum += 10;
            }
            else if (s[i - 1] == 'L')
            {
                sum += 50;
            }
            else if (s[i - 1] == 'C')
            {
                sum += 100;
            }
            else if (s[i - 1] == 'D')
            {
                sum += 500;
            }
            else if (s[i - 1] == 'M')
            {
                sum += 1000;
            }
        }
        return sum;
    }
};

int main()
{
	Solution s;
	vector<string> roma = {"III","IV","IX","LVIII","MCMXCIV"};
	for (auto r:roma)
		cout << s.romanToInt(r) << endl;

	return 0;
}

解法2： 

#include <bits/stdc++.h>
using namespace std;

class Solution
{
public:
    int romanToInt(string s)
    {
        int result = 0;
        int n = s.length();
        for (int i = 0; i < n; i++)
        {
            switch (s[i])
            {
            case 'I':
                if (i < n - 1 && s[i + 1] == 'V')
                {
                    result += 4;
                    i++;
                }
                else if (i < n - 1 && s[i + 1] == 'X')
                {
                    result += 9;
                    i++;
                }
                else
                    result++;
                break;
            case 'V':
                result += 5;
                break;
            case 'X':
                if (i < n - 1 && s[i + 1] == 'L')
                {
                    result += 40;
                    i++;
                }
                else if (i < n - 1 && s[i + 1] == 'C')
                {
                    result += 90;
                    i++;
                }
                else
                    result += 10;
                break;
            case 'L':
                result += 50;
                break;
            case 'C':
                if (i < n - 1 && s[i + 1] == 'D')
                {
                    result += 400;
                    i++;
                }
                else if (i < n - 1 && s[i + 1] == 'M')
                {
                    result += 900;
                    i++;
                }
                else
                    result += 100;
                break;
            case 'D':
                result += 500;
                break;
            case 'M':
                result += 1000;
            }
        }
        return result;
    }
};

int main()
{
	Solution s;
	vector<string> roma = {"III","IV","IX","LVIII","MCMXCIV"};
	for (auto r:roma)
		cout << s.romanToInt(r) << endl;

	return 0;
}

解法3：  

#include <bits/stdc++.h>
using namespace std;

class Solution
{
public:
    int romanToInt(string s)
    {
        int result = 0;
        map<char, int> luomab;

        luomab.insert(map<char, int>::value_type('I', 1));
        luomab.insert(map<char, int>::value_type('V', 5));
        luomab.insert(map<char, int>::value_type('X', 10));
        luomab.insert(map<char, int>::value_type('L', 50));
        luomab.insert(map<char, int>::value_type('C', 100));
        luomab.insert(map<char, int>::value_type('D', 500));
        luomab.insert(map<char, int>::value_type('M', 1000));
        for (int i = 0; i < s.length(); i++)
        {
            if (luomab[s[i]] >= luomab[s[i + 1]])
                result += luomab[s[i]];
            else
            {
                result += (luomab[s[i + 1]] - luomab[s[i]]);
                i++;
            }
        }
        return result;
    }
};

int main()
{
	Solution s;
	vector<string> roma = {"III","IV","IX","LVIII","MCMXCIV"};
	for (auto r:roma)
		cout << s.romanToInt(r) << endl;

	return 0;
}

29. 两数相除

给定两个整数，被除数 dividend 和除数 divisor。将两数相除，要求不使用乘法、除法和 mod 运算符。

返回被除数 dividend 除以除数 divisor 得到的商。

整数除法的结果应当截去（truncate）其小数部分，例如：truncate(8.345) = 8 以及 truncate(-2.7335) = -2

示例 1:

输入: dividend = 10, divisor = 3
输出: 3
解释: 10/3 = truncate(3.33333..) = truncate(3) = 3

示例 2:

输入: dividend = 7, divisor = -3
输出: -2
解释: 7/-3 = truncate(-2.33333..) = -2

提示：

  • 被除数和除数均为 32 位有符号整数。
  • 除数不为 0。
  • 假设我们的环境只能存储 32 位有符号整数，其数值范围是 [−2^31,  2^31 − 1]。本题中，如果除法结果溢出，则返回 2^31 − 1。

解法1：  

#include <bits/stdc++.h>
using namespace std;

class Solution
{
public:
    int divide(int dividend, int divisor)
    {
        int INI_MIN = -2147483648, INI_MAX = 2147483647;
        if (dividend == divisor)
            return 1;
        if (divisor == 1)
            return dividend;
        if (dividend == INI_MIN && divisor == -1)
            return INI_MAX;
        if (divisor == INI_MIN)
        {
            if (dividend == INI_MIN)
                return 1;
            else
                return 0;
        }

        bool sign = false;
        if (dividend > 0 && divisor > 0 || dividend < 0 && divisor < 0)
        {
            sign = true;
        }

        int result_1 = 0;
        if (dividend == INI_MIN)
        {
            if (divisor > 0)
                dividend = dividend + divisor;
            else
                dividend = dividend - divisor;
            result_1++;
        }

        dividend = abs(dividend);
        divisor = abs(divisor);
        while (dividend >= divisor)
        {
            unsigned int temp = divisor, res = 1;

            while (dividend >= (temp << 1))
            {
                res <<= 1;
                temp <<= 1;
            }

            result_1 += res;
            dividend -= temp;
        }
        if (sign == true)
        {
            return result_1;
        }
        else
        {
            return -result_1;
        }
    }
};

int main()
{
	Solution s;
	
	cout << s.divide(10, 3) << endl;
	cout << s.divide(7, -3) << endl;

	return 0;
}

解法2：  

#include <bits/stdc++.h>
using namespace std;

class Solution
{
public:
    int divide(int dividend, int divisor)
    {
        int signal = 1;
        unsigned int dvd = dividend;
        if (dividend < 0)
        {
            signal *= -1;
            dvd = ~dvd + 1;
        }
        unsigned int dvs = divisor;
        if (divisor < 0)
        {
            signal *= -1;
            dvs = ~dvs + 1;
        }
        int shift = 0;
        while (dvd > dvs << shift)
        {
            shift++;
        }
        unsigned int res = 0;
        while (dvd >= dvs)
        {
            while (dvd < dvs << shift)
            {
                shift--;
            }
            res |= (unsigned int)1 << shift;
            dvd -= dvs << shift;
        }
        if (signal == 1 && res >= INT_MAX)
        {
            return INT_MAX;
        }
        else
        {
            return res * signal;
        }
    }
};

int main()
{
	Solution s;
	
	cout << s.divide(10, 3) << endl;
	cout << s.divide(7, -3) << endl;

	return 0;
}

解法3：  

#include <bits/stdc++.h>
using namespace std;

class Solution
{
public:
    int divide(int dividend, int divisor)
    {
        if (dividend == INT_MIN && divisor == -1)
            return INT_MAX;
        if (dividend == 0)
            return 0;
        int sign = ((dividend < 0) ^ (divisor < 0)) ? -1 : 1;
        long x = (dividend < 0) ? -(long)dividend : (long)dividend;
        long y = (divisor < 0) ? -(long)divisor : (long)divisor;
        long result = 0;
        while (x >= y)
        {
            long temp = y, mid = 1;
            while (x >= (temp << 1))
            {
                mid <<= 1;
                temp <<= 1;
            }
            result += mid;
            x -= temp;
        }
        return sign > 0 ? result : -result;
    }
};

int main()
{
	Solution s;
	
	cout << s.divide(10, 3) << endl;
	cout << s.divide(7, -3) << endl;

	return 0;
}

完

基于C++的高等数学问题的解决与应用
tlr123456的博客
07-04 3776
在各个学科和行业中，高等数学问题的解决和应用都发挥着重要的作用。C++是一种广泛应用于软件开发的高级编程语言，它结合了C语言的高效性和面向对象编程的灵活性。C++具有丰富的语法和强大的特性，使其成为科学计算和数值模拟领域的首选语言。本文将介绍C++的基本语法和特性，并探讨C++在科学计算中的优势。本文通过介绍高等数学在C++科学计算和数据分析中的应用，展示了该领域的一些重要案例分析，并提供了相应的代码实现。在科学计算领域，高等数学为物理学、工程学等学科提供了基本工具。
用C/C++解决一些数学问题（二）
季风博客
05-27 2416
1：在日常生活中，一大堆数据，我们要求出这些数据的最大值，这里以整数为例，主要也是重新缕清一下思路       需求：求出20个数中的最大的数，并且输出： #include using namespace std; int main() { while (true) { int a[20]; for(int i=0;i<20;i++) { cout<<"请输入第"<<i
c++解数学题
Thj20232024的博客
12-05 423
【代码】c++解数学题。
学了C++，高中最绕的数学题就是如此简单
qq_44486437的博客
03-24 663
//逻辑问题 /*两个乒乓球队进行比赛，各出3人。甲队为A,B,C3人，甲队为x,y,z3人。抽签决定比赛名单。有人向队员打听比赛的名单，A说他不和x比，C说他不和x，z比。编程找出3对赛手的名单。 解：问题分析：假设i是A的对手，j是B的对手，k是C的对手，i，j，k分别是x,y,z之一，且i,j,k互不相等，同时还要满足条件i?!=?‘x’&&k?!=?‘x’&&amp...
C++算法之巧解数学问题
yohnyang的博客
09-13 1954
巧解数学问题 利用C++求解经典数学问题 1.公倍数与公因数 利用辗转相除法，我们可以很方便地求得两个数的最大公因数（greatest common divisor，gcd）；将两个数相乘再除以最大公因数即可得到最小公倍数（least common multiple, lcm）。 首先介绍一下辗转相除法： #include<iostream> #include<cstdio> using namesapce std; int fun(int m,int n) { int r
精选资源
2025 版 C++ 面试八股文（力扣c++面试突破）全解析：120 个核心考点 + 300 行源代码示例（含语言特性 / 内存管理 / STL / 多线程 / 模板元编程 附大厂面试官追问指南）
04-08
在深入分析C++程序设计语言时，理解内存管理是一个至关重要的部分，它涉及到程序运行时的数据存储和资源分配。C++语言将内存划分为几个不同的区域，包括栈、堆、全局/静态存储区、常量存储区和代码区。栈内存用于...
精选资源
leetcode下载-Leetcode-practice:力扣C++
06-29
给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。 有效字符串需满足： 左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 注意空字符串可被认为是有效字符串。 来源：...
力扣刷题 | 二叉树
12-20
文章目录总述基本概念二叉树性质二叉树遍历94 二叉树的中序遍历95 不同的二叉搜索树296 不同的二叉搜索树98 验证二叉搜索树100 相同的树101 对称二叉树102 二叉树的层序遍历...满二叉树：除了叶结点外每一个结点都有左
力扣面试经典150题力扣面试经典150题
11-21
"力扣面试经典150题"是一系列精选的题目，旨在帮助面试者熟悉常见的面试问题，提升解决问题的能力。 在LeetCode中，面试经典150题主要分为以下几个类别： 1. **数组**：数组是最基础的数据结构，涉及到的问题包括...
精选资源
力扣Hot100题单个人计划c++版（五）（csdn）————程序.pdf
12-05
【力扣Hot100题单个人计划c++版（五）】是一个关于在LeetCode平台上刷题的个人计划，这个计划特别关注C++语言的实现，并且已经更新到了第五部分。该计划的目标是解决LeetCode热门问题列表中的前100道题目，通过每日...
c++ 外婆的数学题
weixin_30511039的博客
08-11 280
外婆的数学题 题目描述 小C是个数学迷，总是缠着曾经是数学老师的外婆出题考考自己。外婆当然乐意啦，于是就在纸上写下了下面这个算式： 'x^y mod 10007 = ? 这下可把小C给难住了，你能帮助他解决这个问题么？ 输入 输入包括两个整数，分别表示：x、y。 输出 输出包括一个整数，表示算式的答案。 样例输入 2 10 样例输出 1024 提示 对于100%的数据中，1≤x≤100,...
C++解方程组的库
BlueMan
04-26 3276
请注意，Eigen的非线性优化模块并不包含真正的BFGS实现，而是提供了Levenberg-Marquardt算法，它更适合于非线性最小二乘问题。它支持多种类型的矩阵运算，包括求解线性方程组。对于更复杂的问题，你可能需要更高级的数值优化库，如Ceres Solver或NLopt，它们提供了更多的优化算法和更好的稳定性。这个示例中，我们定义了一个非线性方程组和它的雅可比矩阵，然后使用牛顿法进行迭代求解。请注意，这个模块是Eigen的一部分，但并不属于其稳定的官方API，因此在未来的版本中可能会有所变化。
C++基础算法①——高精度加减法计算
博樽
03-14 1万+
高精度导论、高精度+低精度、高精度+高精度、高精度减法。
C++数学与算法系列之初等数论
y6123236的专栏
12-21 2221
数论是一个复杂庞大的体系，至今为止，数论中有些经典问题已经被证明，有些问题还需时日。随着计算机硬件的发展，将会为解决纯数学理论提供了强有力的支撑，相信不久的将来，很多问题都可以解决。本文仅讲解了常用的数论问题，除此之外，还有很多其它有趣的数论问题，有兴趣者可以自行了解。
c++-用c++解决简单数学问题
万物复苏101的博客
11-27 460
这段代码演示了如何用C++语言解决几个简单的数学问题，包括求平方根、绝对值、最大值、最小值和幂运算。通过调用C++的内置函数，可以很方便地解决这些问题。将需要计算的数值传入相应的函数，然后输出结果即可。
[C++][题解]小学数学题
wingaso的博客
01-20 1046
C++训练题
C++学习 数学计算
weixin_46205351的博客
09-01 849
C++学习 数学问题
经典数学问题“空瓶换酒”求解（C/C++）
热门推荐
paschen的专栏
04-07 1万+
经典数学问题“空瓶换酒”：某啤酒店可用a(&gt;0)个空啤酒瓶换b(&lt;a)瓶啤酒，某人一次购买n瓶啤酒，问其最多能够喝多少瓶啤酒？通常这类问题希望我们要“投机取巧”，即先找店家或他人借空瓶，换酒喝完后再如数归还为求全面，本人分别对“允许借空瓶”与“不允许借空瓶”两种情况进行推导（一）允许借空瓶：能借到空瓶我们可以尽可能做到物尽其用每换一次需要a个空瓶，而换来的酒喝完后又有b个空瓶，实际每次...
c++经典题目（小学生算数）
midautumnday的博客
10-08 2843
小学生算术 描述 很多小学生在学习加法时，发现“进位”特别容易出错。 你的任务是计算两个正整数在相加时有多少次进位。你编制的程序应当可以连续处理多组数据，直到读到两个0（这是输入结束标记）。 输入 输入文件名为carry.in。 输入文件中，每行上有两个正整数x,y，中间用一个空格隔开，最后一行是0 0。 输出 输出文件名为carry.out。 输出文件对于每行数据输出一行，每行中只有一个整数，表示x,y相加时有多少次进位。 输入样例 1 123 4567 555 55.
力扣第一题用c解为啥比c++复杂的多
最新发布
10-05
使用C语言解决力扣第一题（两数之和）比使用C++复杂，主要体现在以下几个方面： ### 数据结构和库的支持 - **C语言**：C语言标准库提供的数据结构和功能相对基础，在处理两数之和问题时，若要使用哈希表优化查找效率，没有像C++那样直接可用的标准哈希表实现。以引用[1]为例，使用uthash需要额外去搜索下载地址和导入教程，因为一般编译环境不自带，这无疑增加了实现的复杂性。 - **C++**：C++的标准模板库（STL）提供了丰富的数据结构和算法，对于两数之和问题，可以直接使用`unordered_map`这种哈希表容器，如引用[3]所示，代码实现简洁，无需额外处理哈希表的实现细节。 ### 内存管理 - **C语言**：在C语言中，动态内存分配和释放需要手动管理。例如引用[4]中，返回的数组需要使用`malloc`进行动态分配，并且要假设调用者会调用`free`来释放内存。手动管理内存容易出现内存泄漏、悬空指针等问题，增加了代码的复杂性和出错的风险。 - **C++**：C++引入了RAII（资源获取即初始化）机制，对于动态内存管理，有智能指针（如`std::unique_ptr`、`std::shared_ptr`）等工具，能自动处理内存的分配和释放，减少了手动管理内存的负担。 ### 代码的简洁性和可读性 - **C语言**：由于缺乏高级语言特性和丰富的库支持，C语言代码往往需要编写更多的底层逻辑。在两数之和问题中，若不使用哈希表，通常会采用暴力循环的方法，如引用[4]中的双重循环，代码的时间复杂度较高，且在处理更复杂的情况时，代码会变得冗长和难以维护。 - **C++**：C++的语法更加灵活，结合STL可以用更简洁的代码实现相同的功能。例如在处理数组和容器时，可以使用范围for循环、lambda表达式等特性，使代码更加简洁易读。 ### 类型安全 - **C语言**：C语言是弱类型语言，在类型转换和函数调用时，编译器的类型检查相对宽松，容易出现类型不匹配等错误，需要程序员更加小心地处理类型问题。 - **C++**：C++是强类型语言，编译器会进行更严格的类型检查，能在编译阶段发现更多的类型错误，提高了代码的安全性和可靠性。 ```c // C语言实现两数之和（暴力法） #include <stdio.h> #include <stdlib.h> int* twoSum(int* nums, int numsSize, int target, int* returnSize) { int i, j; int* result = (int*)malloc(2 * sizeof(int)); *returnSize = 2; for (i = 0; i < numsSize; i++) { for (j = i + 1; j < numsSize; j++) { if (nums[i] + nums[j] == target) { result[0] = i; result[1] = j; return result; } } } return NULL; } ``` ```cpp // C++实现两数之和（哈希表法） #include <iostream> #include <vector> #include <unordered_map> std::vector<int> twoSum(std::vector<int>& nums, int target) { std::unordered_map<int, int> hashMap; for (int i = 0; i < nums.size(); i++) { int complement = target - nums[i]; if (hashMap.find(complement) != hashMap.end()) { return {hashMap[complement], i}; } hashMap[nums[i]] = i; } return {}; } ```
评论 77
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Hann Yang

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值