算法中的数

已于 2024-02-21 23:23:10 修改
阅读量989 收藏 20
点赞数 25
文章标签： c++ 算法
于 2024-01-21 16:28:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a111737289291/article/details/135728738
版权

目录

1.数

1.1.什么是数

1.2.数的进制转换

1.2.1.C++中的进制：

1.2.2.10进制数转n（2≤n≤16）进制数

1.2.3.n进制数转10进制数

1.3.n进制加法

1.4.回文数

1.5.例题

1.5.1.回文平方数 Palindromic Squared

1.5.2.回文数

1.6.素数（质数）

1.7.完全平方数

1.8.中位数

1.数

1.1.什么是数

一个用作计数、标记或用作量度的抽象概念。代表数的一系列符号，包括数字、运算符号等统称为记数系统。在日常生活中，数通常出现在标记、序列号等上。在数学里，数的定义延伸至包含如分数、负数、无理数及复数等抽象化的概念。

C++中的数值类型

  1. 整数类型：

    • int：表示整数，通常为32位（取决于编译器和平台）。
    • short：短整数，通常为16位。
    • long：长整数，通常为32位或64位。
    • long long：更长的整数，通常为64位（C++中通常 采用下面这句话将long long用ll表示，定义long long类型的即可使用ll，例如long long a<=>ll a）。 
      #define ll long long

  2. 无符号整数类型：

    • unsigned int：无符号整数，与int具有相同的大小，但只能表示非负数。
    • unsigned short：无符号短整数，与short具有相同的大小，但只能表示非负数。
    • unsigned long：无符号长整数，与long具有相同的大小，但只能表示非负数。
    • unsigned long long：更长的无符号整数，与long long具有相同的大小，但只能表示非负数。

  3. 浮点数类型：

    • float：单精度浮点数，通常为32位，可以表示大约6到7位有效数字。
    • double：双精度浮点数，通常为64位，可以表示大约15到16位有效数字。
    • long double：更长的浮点数，通常为80位或128位，具有更高的精度。

1.2.数的进制转换

数的进制转换是指将一个数从一种进制表示转换为另一种进制表示的过程。常见的进制包括二进制、八进制、十进制和十六进制

1.2.1.C++中的进制：

C++ 字面值常量默认用十进制表示：

int num = 19;

C++数值的二进制表示法：

int num = 0B10011;//十进制数为19，0B表示2进制

C++ 数值的八进制表示法：

int num = 023;//十进制为19，0表示8进制

C++数值的十六进制表示法：

int num = 0x13;//十进制数为19，0x表示16进制数

C++中以上定义的进制数，编译器会统一转换成十进制输出：

cout << num;
//以上定义的进制数执行这句话均会输出19

1.2.2.10进制数转n（2≤n≤16）进制数

10进制数转n进制数采用除余法：

比如10进制数35转化为二进制：

86c705856d1e4d128cfbd51a587210d2.png

最终得到二进制数为100011

#include<bits/stdc++.h>
using namespace std;
#define ll long long
void binary_conversion(int num, int n) {
    string x = "0123456789ABCDEF";
    string numbc;
    while (num) {
        numbc += x[num % n];//先得到低位所以最后要反转
        num = num / n;
    }
    reverse(numbc.begin(), numbc.end());//字符串反转
    cout << numbc;
}
int main() {
    ios::sync_with_stdio;
    cin.tie(0);
    cout.tie(0);
    int num, n;
    cout << "输入十进制数num，和进制数n：";
    cin >> num >> n;
    binary_conversion(num, n);
    return 0;
}
/*输入19 2
输出：10011*/

1.2.3.n进制数转10进制数

n进制数转10进制数采用公式法，公式为：7ae635a58e90448b8ca0c01ff8dd8b6d.png

例如：2进制数1011转10进制：

7e4e0adc4eff46b5bc9f3ddb89e4d729.png

#include<bits/stdc++.h>
using namespace std;
#define ll long long
void binary_conversion(string num, int n) {
    int numresult = 0;
    for (int i = num.length() - 1; i >= 0; i--) {
        if (num[i] >= 'A' && num[i] <= 'F') {
            numresult += (num[i] - 'A' + 10) * pow(n, num.length() - i - 1);
        }
        else {
            numresult += (num[i] - '0') * pow(n, num.length() - i - 1);
        }
    }
    cout << numresult;
}
int main() {
    ios::sync_with_stdio;
    cin.tie(0);
    cout.tie(0);
    string num;
    int n;
    cout << "输入n进制数num，和其进制数n：";
    cin >> num >> n;
    binary_conversion(num, n);
    return 0;
}
/*输入1A 16
输出：26*/

1.3.n进制加法

n进制加法是指在基数为n的进制系统中进行加法运算。在这种进制系统中，数字的取值范围为0到n-1。要进行n进制加法，可以按照以下步骤进行：

  1. 将两个加数从右到左逐位相加，从最低位开始。
  2. 如果相加的结果小于n，则直接写下该结果。
  3. 如果相加的结果大于等于n，则将结果除以n，得到商和余数。将余数写下作为当前位的结果，并将商作为下一位的进位。
  4. 继续对下一位进行相加，直到所有位都处理完毕。
  5. 如果最高位的相加产生了进位，需要将进位写下。
#include<bits/stdc++.h>
using namespace std;
#define ll long long
void n_addition(string num1, string num2, int d) {
    int len1 = num1.length() - 1, len2 = num2.length() - 1;
    vector<int> ans(max(num1.length(), num2.length()) + 1, 0);
    int anslen = max(num1.length(), num2.length());
    while (len1 >= 0 && len2 >= 0) {
        int t1, t2;
        if (num1[len1] >= 'A' && num1[len1] <= 'F') {
            t1 = num1[len1] - 'A' + 10;
        }
        else {
            t1 = num1[len1] - '0';
        }
        if (num2[len2] >= 'A' && num2[len2] <= 'F') {
            t2 = num2[len2] - 'A' + 10;
        }
        else {
            t2 = num2[len2] - '0';
        }
        len1--;
        len2--;
        ans[anslen] += t1 + t2;
        if (ans[anslen] >= d) {
            ans[anslen - 1] += ans[anslen] / d;
            ans[anslen] = ans[anslen] % d;
        }
        anslen--;
    }
    while (len1 >= 0) {
        int t1;
        if (num1[len1] >= 'A' && num1[len1] <= 'F') {
            t1 = num1[len1] - 'A' + 10;
        }
        else {
            t1 = num1[len1] - '0';
        }
        len1--;
        ans[anslen] += t1;
        if (ans[anslen] >= d) {
            ans[anslen - 1] += ans[anslen] / d;
            ans[anslen] = ans[anslen] % d;
        }
        anslen--;
    }
    while (len2 >= 0) {
        int t2;
        if (num2[len2] >= 'A' && num2[len2] <= 'F') {
            t2 = num2[len2] - 'A' + 10;
        }
        else {
            t2 = num2[len2] - '0';
        }
        len2--;
        ans[anslen] += t2;
        if (ans[anslen] >= d) {
            ans[anslen - 1] += ans[anslen] / d;
            ans[anslen] = ans[anslen] % d;
        }
        anslen--;
    }
    
    string result;
    if (ans[0] != 0) {
        result += '1';
    }
    for (int i = 1; i < max(num1.length(), num2.length()) + 1; i++) {
        if (ans[i] >= 0 && ans[i] <= 9) {
            result += (char)(ans[i] + '0');
        }
        else {
            result += (char)(ans[i] - 10 + 'A');
        }
    }
    cout << result;
}
int main() {
    ios::sync_with_stdio;
    cin.tie(0);
    cout.tie(0);
    string num1, num2;
    int d;
    cin >> d >> num1 >> num2;
    n_addition(num1, num2, d);
    return 0;
}
/*输入16 A1 A2
输出143
输入16 111 1A
输出12B*/

1.4.回文数

回文数是指从左到右和从右到左读取都相同的数。例如，121、12321和1221都是回文数。
要判断一个数是否是回文数，可以按照以下步骤进行：

  1. 将给定的数转换为字符串。
  2. 比较字符串的正序和倒序是否相同。如果相同，则该数是回文数；如果不同，则不是回文数。
#include<bits/stdc++.h>
using namespace std;
#define ll long long
bool palindrome(string num) {
    bool f = true;
    int start = 0, end = num.length() - 1;
    while (start < end) {
        if (num[start] != num[end]) {
            f = false;
            break;
        }
        start++;
        end--;
    }
    return f;
}
int main() {
    ios::sync_with_stdio;
    cin.tie(0);
    cout.tie(0);
    string num;
    cout << "输入需要判断的数num：";
    cin >> num;
    if (palindrome(num)) {
        cout << "YES";
    }
    else {
        cout << "NO";
    }
    return 0;
}
/*输入111
输出：YES
输入1221
输出：YES
输入123
输出：NO*/

1.5.例题

1.5.1.回文平方数 Palindromic Squared

f579feac16594fe09e968f59051c36a5.png

题目解析：判断10进制数[1,300]这个区间中的平方转换成B进制后是否为回文

#include<bits/stdc++.h>
using namespace std;
#define ll long long
string fun(int n, int d) {
    string r = "", t = "0123456789ABCDEFGHIJK";
    while (n != 0) {
        r += t[n % d];
        n = n / d;
    }
    reverse(r.begin(), r.end());//字符反转
    return r;
}//将数字n转化为d进制，并转化为字符串
bool huiwen(string M) {
    int pre = 0, post = M.size() - 1;
    while (pre < post) {
        if (M[pre++] != M[post--]) return false;
    }
    return true;
}

int main() {
    ios::sync_with_stdio;
    cin.tie(0);
    cout.tie(0);
    int B;
    string r1;
    cin >> B;
    for (int i = 1; i <= 300; i++) {
        r1 = fun(i * i, B);//将i的平方转化为B进制的字符串
        if (huiwen(r1)) {
            cout << fun(i, B)/*将i转化为B进制的字符串*/ << " " << r1 << endl;
        }
    }
    return 0;
}

1.5.2.回文数

#include<bits/stdc++.h>
using namespace std;
#define ll long long
string n_addition(string num1, string num2, int d) {//由于本题的num1 和 num2长度一样则可写为下面的代码，对比num1和num2长度不同的写法
    /*int len1 = num1.length() - 1, len2 = num2.length() - 1;
    vector<int> ans(max(num1.length(), num2.length()) + 1, 0);
    int anslen = max(num1.length(), num2.length());
    while (len1 >= 0 && len2 >= 0) {
        int t1, t2;
        if (num1[len1] >= 'A' && num1[len1] <= 'F') {
            t1 = num1[len1] - 'A' + 10;
        }
        else {
            t1 = num1[len1] - '0';
        }
        if (num2[len2] >= 'A' && num2[len2] <= 'F') {
            t2 = num2[len2] - 'A' + 10;
        }
        else {
            t2 = num2[len2] - '0';
        }
        len1--;
        len2--;
        ans[anslen] += t1 + t2;
        if (ans[anslen] >= d) {
            ans[anslen - 1] += ans[anslen] / d;
            ans[anslen] = ans[anslen] % d;
        }
        anslen--;
    }
    while (len1 >= 0) {
        int t1;
        if (num1[len1] >= 'A' && num1[len1] <= 'F') {
            t1 = num1[len1] - 'A' + 10;
        }
        else {
            t1 = num1[len1] - '0';
        }
        len1--;
        ans[anslen] += t1;
        if (ans[anslen] >= d) {
            ans[anslen - 1] += ans[anslen] / d;
            ans[anslen] = ans[anslen] % d;
        }
        anslen--;
    }
    while (len2 >= 0) {
        int t2;
        if (num2[len2] >= 'A' && num2[len2] <= 'F') {
            t2 = num2[len2] - 'A' + 10;
        }
        else {
            t2 = num2[len2] - '0';
        }
        len2--;
        ans[anslen] += t2;
        if (ans[anslen] >= d) {
            ans[anslen - 1] += ans[anslen] / d;
            ans[anslen] = ans[anslen] % d;
        }
        anslen--;
    }*/
    int len = num1.length() - 1;
    vector<int> ans(num1.length() + 1, 0);
    int anslen = num1.length();
    while (len >= 0) {
        int t1, t2;
        if (num1[len] >= 'A' && num1[len] <= 'F') {
            t1 = num1[len] - 'A' + 10;
        }
        else {
            t1 = num1[len] - '0';
        }
        if (num2[len] >= 'A' && num2[len] <= 'F') {
            t2 = num2[len] - 'A' + 10;
        }
        else {
            t2 = num2[len] - '0';
        }
        len--;
        ans[anslen] += t1 + t2;
        if (ans[anslen] >= d) {
            ans[anslen - 1] += ans[anslen] / d;
            ans[anslen] = ans[anslen] % d;
        }
        anslen--;
    }
    string result;
    if (ans[0] != 0) {
        result += '1';
    }
    for (int i = 1; i < max(num1.length(), num2.length()) + 1; i++) {
        if (ans[i] >= 0 && ans[i] <= 9) {
            result += (char)(ans[i] + '0');
        }
        else {
            result += (char)(ans[i] - 10 + 'A');
        }
    }
    return result;
}
bool huiwen(string num) {
    bool f = true;
    int start = 0, end = num.length() - 1;
    while (start < end) {
        if (num[start] != num[end]) {
            f = false;
            break;
        }
        start++;
        end--;
    }
    return f;

}
int main() {
    ios::sync_with_stdio;
    cin.tie(0);
    cout.tie(0);
    string num;
    int d, step = 0;
    cin >> d >> num;
    for (int i = 1; i <= 30; i++) {
        string reversenum = num;
        reverse(reversenum.begin(), reversenum.end());
        num = n_addition(num, reversenum, d);
        step++;
        if (huiwen(num)) {
            break;
        }
    }
    cout << "step=" << step;
    return 0;
}
/*输入
10
87
输出
step=4*/

1.6.素数（质数）

素数（也称为质数）是指大于1的整数，除了1和自身之外没有其他正因数的数。换句话说，素数只能被1和自身整除，没有其他整数可以整除它。

要判断一个数是否是素数，可以使用以下方法：

  1. 首先，判断该数是否小于2。如果小于2，则不是素数。
  2. 如果该数大于等于2，可以进行以下步骤：
    • 从2开始，逐个判断该数能否被小于它的数的算数平方根整除。如果能整除，则不是素数；如果不能整除，则继续判断下一个数。
    • 判断的范围可以是从2到该数的平方根，因为大于平方根的因子必然对应一个小于平方根的因子。
#include<bits/stdc++.h>
using namespace std;
#define ll long long
bool prime_number(int n) {
    int f = true;
    if(n<2){
        f = false;
    }
    else if (n > 2) {
        for (int i = 2; i <= sqrt(n); i++) {
            if (n % i == 0) {
                f = false;
                break;
            }
        }
    }
    return f;
}

int main() {
    ios::sync_with_stdio;
    cin.tie(0);
    cout.tie(0);
    int n;
    cin >> n;
    if (prime_number(n)) {
        cout << "YES";
    }
    else {
        cout << "NO";
    }
    return 0;
}
/*输入3
输出：YES
输入121
输出：NO*/

1.7.完全平方数

完全平方数是指一个数可以表示为另一个整数的平方。换句话说，完全平方数是某个整数的平方。

要判断一个数是否是完全平方数，可以使用以下方法：

  1. 首先，判断该数是否小于0。如果小于0，则不是完全平方数。
  2. 如果该数大于等于0，可以进行以下步骤：
    • 计算该数的平方根。
    • 将平方根取整得到一个整数。（此处取整可直接强制转换(int)a，属于向下取整）
    • 将这个整数的平方与原数进行比较。如果相等，则是完全平方数；如果不相等，则不是完全平方数。
#include<bits/stdc++.h>
using namespace std;
#define ll long long
bool exact_square(int n) {
    int f;
    if (n < 0) {
        f = false;
    }
    double x = sqrt(n);
    if (x * x != n) {
        f = false;
    }
    else {
        f = true;
    }
    return f;
}

int main() {
    ios::sync_with_stdio;
    cin.tie(0);
    cout.tie(0);
    int n;
    cin >> n;
    if (exact_square(n)) {
        cout << "YES";
    }
    else {
        cout << "NO";
    }
    return 0;
}
/*输入121
输出：YES
输入2
输出：NO*/

1.8.中位数

中位数是一组数据中的中间值。当数据的数量为奇数时，中位数就是排序后的中间值；当数据的数量为偶数时，中位数是排序后中间两个数的平均值。

要计算一组数据的中位数，可以按照以下步骤进行：

  1. 将数据进行排序，从小到大排列。
  2. 如果数据的数量是奇数，中位数就是排序后的中间值。可以通过索引来找到中间值，索引为 (n-1)/2，其中 n 是数据的数量。
  3. 如果数据的数量是偶数，中位数是排序后中间两个数的平均值。可以通过索引来找到这两个数，索引分别为 n/2 和 (n/2)-1，其中 n 是数据的数量。
#include<bits/stdc++.h>
using namespace std;
#define ll long long
void median(vector<int> a) {
    sort(a.begin(), a.end());
    if (a.size() % 2 == 0) {
        cout << (double)((a[a.size() / 2] + a[(a.size() - 1) / 2]) / 2.0);
    }
    else {
        cout << (double)(a[(a.size() - 1) / 2]);
    }
}

int main() {
    ios::sync_with_stdio;
    cin.tie(0);
    cout.tie(0);
    int n;
    cin >> n;//n为该组数据的大小
    vector<int> a(n);
    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }
    median(a);
    return 0;
}
/*输入
5
3 2 1 5 4
输出：3
输入
6
2 3 1 5 4 6
输出：3.5*/

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

JayNe61

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

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

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

打赏作者

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

抵扣说明：

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

余额充值