数位拆解
#include <cstdio>
using namespace std;
int main() {
int a, b; // 保存两个整数的变量
while (scanf("%d%d", &a, &b) != EOF) {
int buf1[20], buf2[20], size1 = 0, size2 = 0;
while (a != 0) {
buf1[size1++] = a % 10;
a /= 10;
}
while (b != 0) {
buf2[size2++] = b % 10;
b /= 10;
}
int ans = 0;
for (int i = 0; i < size1; i++) {
for (int j = 0; j < size2; j++)
ans += buf1[i] * buf2[j];
}
printf("%d\n", ans);
}
return 0;
}#include <cstdio>
using namespace std;
int main() {
char a[11], b[11];
while (scanf("%s%s", a, b) != EOF) {
int ans = 0;
for (int i = 0; a[i] != 0; i++) {
for (int j = 0; b[j] != 0; j++)
ans += (a[i] - '0') * (b[j] - '0');
}
printf("%d\n", ans);
}
return 0;
}进制转换
#include <cstdio>
int main() {
long long a, b;
int m;
while (scanf("%d", &m) != EOF) {
if (m == 0)
break;
scanf("%lld%lld", &a, &b);
a = a + b;
int ans[50], size = 0;
ans[size++] = a % m;
a = a/m;
while (a != 0) {
ans[size++] = a % m;
a = a/m;
}
for (int i = size-1; i >= 0; i--) {
printf("%d", ans[i]);
}
printf("\n");
}
return 0;
}数制转换
#include <cstdio>
#include <cstring>
int main() {
int a, b;
char str[40];
while (scanf("%d%s%d", &a, str, &b) != EOF) {
// tmp为我们将要计算的a进制对应的十进制数，length为字符串长度方便我们从低到高位遍历每个数位上的数
// c为各个数位的权重，初始化为1，表示最低位数位权为1，之后每位权重都是前一位权重的a倍
int tmp = 0, length = strlen(str), c = 1;
for (int i = length-1; i >= 0; i--) {
int x;
if (str[i] >= '0' && str[i] <= '9')
x = str[i] - '0'; // 当字符在0到9之间，计算其代表的数字
else if (str[i] >= 'a' && str[i] <= 'z')
x = str[i] - 'a' + 10;
else
x = str[i] - 'A' + 10;
tmp += x * c;
c *= a;
}
char ans[40], size = 0;
int x = tmp % b;
ans[size++] = (x < 10) ? x+'0' : x-10+'A';
tmp /= b;
while (tmp != 0) {
x = tmp % b;
ans[size++] = (x < 10) ? x+'0' : x-10+'A';
tmp /= b;
}
for (int i = size-1; i >= 0; i--)
printf("%c", ans[i]);
printf("\n");
}
return 0;
}最大公约数
#include <cstdio>
int gcd(int a, int b){
if (b == 0)
return a;
else
return gcd(b, a%b);
}
int main() {
int a, b;
while (scanf("%d%d", &a, &b) != EOF) {
printf("%d\n", gcd(a, b));
}
return 0;
}最小公倍数
#include <cstdio>
int gcd(int a, int b) {
int tmp;
while (b != 0) {
tmp = a % b;
a = b;
b = tmp;
}
return a;
}
int main() {
int a, b;
while (scanf("%d%d", &a, &b) != EOF) {
printf("%d\n", a*b/gcd(a, b));
}
return 0;
}素数筛法
#include <cstdio>
#include <cmath>
bool judge(int x) {
if (x <= 1)
return false;
int bound = (int)sqrt(x)+1;
for (int i = 2; i < bound; i++) {
if (x % i == 0)
return false;
}
return true;
}
int main() {
int x;
while (scanf("%d", &x) != EOF) {
if (judge(x))
printf("yes\n");
else
printf("no\n");
}
return 0;
}分解素因数
#include <cstdio>
int prime[10000]; // 保存筛得的素数
int primeSize; // 保存素数个数
bool mark[10001]; // 若mark[x]为true，则表示该数x已被标注为非素数
void init() {
for (int i = 1; i <= 10000; i++)
mark[i] = false;
primeSize = 0;
for (int i = 2; i <= 10000; i++) {
if (mark[i] == true)
continue;
prime[primeSize++] = i;
for (int j = i*i; j <= 10000; j += i)
mark[j] = true;
}
}
int main() {
init();
int n;
while (scanf("%d", &n) != EOF) {
int ansPrime[30];
int ansSize = 0;
int ansNum[30];
for (int i = 0; i < primeSize; i++) {
if (n % prime[i] == 0) {
ansPrime[ansSize] = prime[i];
ansNum[ansSize] = 0;
while (n % prime[i] == 0) {
ansNum[ansSize]++;
n /= prime[i];
}
ansSize++;
if (n == 1)
break;
}
}
if (n != 1) {
ansPrime[ansSize] = n;
ansNum[ansSize++] = 1;
}
int ans = 0;
for (int i = 0; i < ansSize; i++)
ans += ansNum[i];
printf("%d\n", ans);
}
return 0;
}#include <iostream>
#include <cstdio>
bool mark[1010];
int prime[1010];
int primeSize;
void init() {
primeSize = 0;
for (int i = 2; i <= 1000; i++) {
if (mark[i] == true)
continue;
prime[primeSize++] = i;
for (int j = i*i; j <= 1000; j += i)
mark[j] = true;
}
}
int cnt[1010]; // cnt[i]用来表示prime[i]所保存的素数在n!中的因子数，即n!分解因数后，素因子prime[i]所对应的幂指数，可能为0
int cnt2[1010]; // cnt[i]用来表示prime[i]所保存的素数在a中的因子数
int main() {
int n, a;
init();
while (scanf("%d%d", &n, &a) == 2) {
for (int i = 0; i < primeSize; i++) {
cnt[i] = cnt[2] = 0;
}
for (int i = 0; i < primeSize; i++) {
int t = n; // 用临时变量保存n的值
while (t) {
cnt[i] += t/prime[i];
t = t/prime[i];
} // 依次计算t/prime[i]^k，直到t/prime[i]^k变为0
}
int ans = 123123123;
for (int i = 0; i < primeSize; i++) {
while (a%prime[i] == 0) {
cnt2[i]++;
a /= prime[i];
} // 计算a中素因数prime[i]对应的幂指数
if (cnt2[i] == 0)
continue;
if (cnt[1]/cnt[2] < ans)
ans = cnt[i] / cnt2[i]; // 统计这些商的最小值
}
printf("%d\n", ans);
}
return 0;
}
二分求幂
#include <cstdio>
int main() {
int a, b;
while (scanf("%d%d", &a, &b) != EOF) {
if (a == 0 && b == 0)
break;
int ans = 1;
while (b != 0) {
if (b % 2 == 1) {
ans *= a;
ans %= 1000;
}
b /= 2;
a *= a;
a %= 1000;
}
printf("%d\n", ans);
}
return 0;
}高精度整数
struct bigInteger {
int digit[1000];
int size;
};#include <cstdio>
#include <cstring>
struct bigInteger { // 高精度整数结构体
int digit[1000]; // 按四位数一个单位保存数值
int size; // 下一个我们未使用的数组单元
void init() {
for (int i = 0; i < 1000; i++)
digit[i] = 0;
size = 0;
}
void set(char str[]) { // 从字符串中提取整数
init();
int L = strlen(str);
for (int i = L-1, j = 0, t = 0, c = 1; i >= 0; i--) {
// 从最后一个字符开始倒序遍历字符串，j控制每4个字符转换为一个数字存入数组
// t临时保存字符转换为数字的中间值，c表示当前位置的权重，按1，10，100，1000顺序变化
t += (str[i] - '0') * c; // 计算这个四位数中当前字符代表的数字，即数字乘以当前位的权重
j++; // 当前转换字符数增加
c *= 10;
if (j == 4 || i== 0) {
digit[size++] = t;
j = 0;
t = 0;
c = 1;
}
}
}
void output() {
for (int i = size-1; i >= 0; i--) {
if (i != size-1)
printf("%04d", digit[i]); // 若当前输出的不是最高位数字，用%04输出前导0，即当前数字不足4位时由0补充，如输出110001的后四位数
else
printf("%d", digit[i]);
}
printf("\n");
}
bigInteger operator + (const bigInteger &A) const { // 加法运算符
bigInteger ret; // 返回值，即两数相加的结果
ret.init(); // 对其初始化
int carry = 0; // 进位，初始值为0
for (int i = 0; i < A.size || i < size; i++) {
int tmp = A.digit[i] + digit[i] + carry; // 计算两个整数当前位以及来自低位的进位和
carry = tmp / 10000; // 计算该位的进位
tmp %= 10000; // 去除进位部分，取后四位
ret.digit[ret.size++] = tmp;
}
if (carry != 0) { // 计算结果后若最高位有进位
ret.digit[ret.size++] = carry; // 保存该进位
}
return ret;
}
}a, b, c;
char str1[1002], str2[1002];
int main() {
while (scanf("%s%s", str1, str2) != EOF) {
a.set(str1);
b.set(str2);
c = a + b;
c.output();
}
return 0;
}#include <cstdio>
#include <cstring>
struct bigInteger { // 高精度整数结构体
int digit[1000]; // 按四位数一个单位保存数值
int size; // 下一个我们未使用的数组单元
void init() {
for (int i = 0; i < 1000; i++)
digit[i] = 0;
size = 0;
}
void set(int x) {
init();
digit[size++] = x % 10000;
x /= 10000;
while (x != 0) {
digit[size++] = x % 10000;
x /= 10000;
}
}
void output() {
for (int i = size-1; i >= 0; i--) {
if (i != size-1)
printf("%04d", digit[i]); // 若当前输出的不是最高位数字，用%04输出前导0，即当前数字不足4位时由0补充，如输出110001的后四位数
else
printf("%d", digit[i]);
}
printf("\n");
}
bigInteger operator * (int x) const { // 乘法运算符
bigInteger ret; // 将要返回的高精度整数
ret.init(); // 对其初始化
int carry = 0; // 进位，初始值为0
for (int i = 0; i < size; i++) {
int tmp = x * digit[i] + carry; // 用小整数x乘以当前位数字并加上来自低位的进位
carry = tmp / 10000; // 计算该位的进位
tmp %= 10000; // 去除进位部分，取后四位
ret.digit[ret.size++] = tmp;
}
if (carry != 0) { // 计算结果后若最高位有进位
ret.digit[ret.size++] = carry; // 保存该进位
}
return ret;
}
}a;
int main() {
int n;
while (scanf("%d", &n) != EOF) {
a.init();
a.set(1);
for (int i = 1; i <= n; i++) {
a = a * i; // 依次乘上每一个数
}
a.output();
}
return 0;
}进制转换
#include <cstdio>
#include <cstring>
#define maxDigits 100
struct bigInteger { // 高精度整数结构体
int digit[maxDigits]; // 按四位数一个单位保存数值
int size; // 下一个我们未使用的数组单元
void init() {
for (int i = 0; i < maxDigits; i++)
digit[i] = 0;
size = 0;
}
void set(int x) {
init();
digit[size++] = x % 10000;
x /= 10000;
while (x != 0) {
digit[size++] = x % 10000;
x /= 10000;
}
}
void output() {
for (int i = size-1; i >= 0; i--) {
if (i != size-1)
printf("%04d", digit[i]); // 若当前输出的不是最高位数字，用%04输出前导0，即当前数字不足4位时由0补充，如输出110001的后四位数
else
printf("%d", digit[i]);
}
printf("\n");
}
bigInteger operator * (int x) const { // 高精度整数与普通整数的乘积
bigInteger ret;
ret.init();
int carry = 0;
for (int i = 0; i < size; i++) {
int tmp = x * digit[i] + carry;
carry = tmp / 10000;
tmp %= 10000;
ret.digit[ret.size++] = tmp;
}
if (carry != 0) {
ret.digit[ret.size++] = carry;
}
return ret;
}
bigInteger operator + (const bigInteger &A) const { // 高精度整数之间的加法运算
bigInteger ret;
ret.init();
int carry = 0;
for (int i = 0; i < A.size || i < size; i++) {
int tmp = A.digit[i] + digit[i] + carry;
carry = tmp / 10000;
tmp %= 10000;
ret.digit[ret.size++] = tmp;
}
if (carry != 0) {
ret.digit[ret.size++] = carry;
}
return ret;
}
bigInteger operator / (int x) const { // 高精度整数除以普通整数
bigInteger ret;
ret.init();
int remainder = 0; // 余数
for (int i = size-1; i >= 0; i--) { // 从最高位至最低位依次完成计算
int t = (remainder*10000 + digit[i]) / x; // 计算当前位置数值加上高位剩余的余数的和对x求得的商
int r = (remainder*10000 + digit[i]) % x; // 计算当前数位值加上搞卫生与的余数的和对x求模后的余数
ret.digit[i] = t; // 保存本位的值
remainder = r; // 保存至本位为止的余数
}
ret.size = 0; // 返回高精度整数的size初始值为0，即当前所有位数字都为0时，digit[0]代表数字0，作为最高有效位，高精度整数即为数字0
for (int i = 0; i < maxDigits; i++) {
if (digit[i] != 0)
ret.size = i;
} // 若存在非0位，确定最高的非0位，作为最高有效位
ret.size++; // 最高有效位的下一位即为下一个我们不曾使用的digit数组单元，确定为size的值
return ret;
}
int operator % (int x) const { // 高精度整数对普通整数求余数
int remainder = 0; // 余数
for (int i = size-1; i >= 0; i--) {
int t = (remainder*10000 + digit[i]) / x;
int r = (remainder*10000 + digit[i]) % x;
remainder = r;
} // 过程同高精度整数对普通整数求商
return remainder; // 返回余数
}
}a, b, c;
char str[10000];
char ans[10000];
int main() {
int n, m;
while (scanf("%d%d", &m, &n) != EOF) {
scanf("%s", str); // 输入m进制数
int L = strlen(str);
a.set(0); // a的初始值为0，用来保存转换成十进制的m进制数
b.set(1); // b的初始值为1，在m进制向十进制转换的过程中，依次代表每一位的权重
for (int i = L-1; i >= 0; i--) { // 由低位至高位转换m进制数至相应的十进制数
int t;
if (str[i] >= '0' && str[i] <= '9') {
t = str[i] - '0';
} else
t = str[i] - 'A' + 10; // 确定当前位字符代表的数字
a = a+b*t; // 累加当前数字乘当前位权重的积
b = b*m; // 计算下一位权重
}
int size = 0; // 代表转换为n进制后的字符个数
do { // 对转换后的十进制数求其n进制值
int t = a % n; // 求余数
if (t >= 10)
ans[size++] = t-10+'a';
else ans[size++] = t+'0'; // 确定当前位字符
a = a / n; // 求商
} while (a.digit[0] != 0 || a.size != 1); // 当a不为0时重复该过程
for (int i = size-1; i >= 0; i--)
printf("%c", ans[i]);
printf("\n");
}
return 0;
}版权声明：本文为beashaper_原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。