一本通 高精度专栏

最新推荐文章于 2023-04-09 08:30:00 发布
最新推荐文章于 2023-04-09 08:30:00 发布
阅读量178 收藏
点赞数
分类专栏： 一本通
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52273733/article/details/118768120
版权

A 求N！的值

【问题描述】

用高精度方法，求N！的精确值(N以一般整数输入)。

【输入形式】

【输出形式】

【样例输入】

10

【样例输出】

3628800

#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
# include<iostream>
# include<algorithm>
# include<cmath>
# include<cstdio>
# include<set>
# include<stack>
# include<queue> 
# include<map>
# include<string>
# include<cstring> 
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int > PII; 
const int mod=1e9+7;
const int MAX=2e6+10;
const int Time=86400;
const int X=131;
const int inf=0x3f3f3f3f;
const double PI = 1e-4;
double pai = 3.14159265358979323846; 

int n;
int a[2005];



int main(){  
   std::ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin >> n;
    a[0] = 1;
    for(int i = 1 ; i <= n ; i ++ ){
    	int b = 0 ;
    	int s;
    	for(int j = 0 ; j < 2000 ; j ++ ){
    		 s = a[j] * i + b;
    		 a[j] = s % 10;
    		 b = s / 10;
		} 
	}
    
    int i;
    for(i = 2004 ; i >= 0 ; i-- )
     if(a[i] != 0) break;
    for(int j = i ; j >= 0 ; j--)
     cout<<a[j];
	return 0;
}

B 求A/B高精度值

【问题描述】

计算A/B的精确值，设A，B是以一般整数输入，计算结果精确到小数后20位（若不足20位，末尾不用补0）。

【输入形式】

【输出形式】

【样例输入1】

4 3

【样例输出1】

4/3=1.33333333333333333333

【样例输入2】

6 5

【样例输出2】

6/5=1.2


#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
# include<iostream>
# include<algorithm>
# include<cmath>
# include<cstdio>
# include<set>
# include<stack>
# include<queue> 
# include<map>
# include<string>
# include<cstring> 
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int > PII; 
const int mod=1e9+7;
const int MAX=2e6+10;
const int Time=86400;
const int X=131;
const int inf=0x3f3f3f3f;
const double PI = 1e-4;
double pai = 3.14159265358979323846; 

int a,b;
int c[25];

int main(){  
   std::ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin >> a >> b;
    cout<< a<<"/"<<b<<"=" <<a/b<<".";
    for(int i = 1 ; i <= 20 ; i++ ){
    	 a = a % b ;
    	 a = a * 10;
    	 c[i] = a / b ;
	}
	int i = 20;
	while(c[i] == 0 && i >=0 ) i--;
	for(int j = 1 ; j <= i ; j++)
	 cout<<c[j];
	return 0;
}

C 求n累加和

【问题描述】

用高精度方法，求s=1+2+3+……+n的精确值(n以一般整数输入)。

【输入形式】

【输出形式】

【样例输入】

10
【样例输出】

55


#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
# include<iostream>
# include<algorithm>
# include<cmath>
# include<cstdio>
# include<set>
# include<stack>
# include<queue> 
# include<map>
# include<string>
# include<cstring> 
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int > PII; 
const int mod=1e9+7;
const int MAX=2e6+10;
const int Time=86400;
const int X=131;
const int inf=0x3f3f3f3f;
const double PI = 1e-4;
double pai = 3.14159265358979323846; 

ll a[2005],b[2005],c[2005],d[2005];
ll n;

void change(int num,ll a[]){
	int cnt = 0;
	while(num/10){
		 a[++cnt] = num%10;
		 num/=10;
	}
	while(num/10 == 0 && num >0){
		 a[++cnt] = num;
		 num/=10;
	}
	a[0] = cnt;
}

void add(ll a[],ll c[]){
	 int  i , x = 0;
	 for( i = 1 ; i <= a[0] || i <= c[0] ; i++ ){
	 	 c[i] = c[i] + a[i] + x;
	 	 x = c[i] / 10;
	 	 c[i] = c[i] % 10;
	 }
	 c[i] = x;
	 if(c[i] == 0 ) c[0] = i - 1;
	  else  c[0] = i;
}

void cf(ll a[],ll b[],ll c[]){
	int i , j ;
	for(int i = 1 ; i <= b[0] ; i ++){
		 int x;
		 for(int j = 1 , x = 0 ; j <= a[0] ; j++ ){
		 	 c[i+j-1] += a[j] * b[i] + x;
		 	 x = c[i+j-1]/10;
		 	 c[i+j-1]%=10;
		 }
		 c[i+a[0]] = x;
	} 
	int l = a[0] + b[0];
	while(c[l] == 0 && l > 1) l--;
	c[0] = l;
}
int main(){  
   std::ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin >> n ;
    change(n + 1 , a);
    change(n / 2 , b);
    cf(a , b , c);
    if(n&1){
    	change(n/2+1,d);
    	 add(d,c);
	}
    for(int j = c[0] ; j >= 1 ; j-- )
     cout<<c[j];
	return 0;
}

D 阶乘和

【问题描述】

已知正整数N（N<=100）,设S=1!+2!+3!+…N!。其中"!"表示阶乘,即N!=123*……(N-1)N，如:3!=123=6。请编程实现：输入正整数N,输出计算结果S的值。

【输入形式】

【输出形式】

【样例输入】

4
【样例输出】

33


#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
# include<iostream>
# include<algorithm>
# include<cmath>
# include<cstdio>
# include<set>
# include<stack>
# include<queue> 
# include<map>
# include<string>
# include<cstring> 
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int > PII; 
const int mod=1e9+7;
const int MAX=2e6+10;
const int Time=86400;
const int X=131;
const int inf=0x3f3f3f3f;
const double PI = 1e-4;
double pai = 3.14159265358979323846; 

int n;
int t[MAX],res[MAX],len = 1,reslen;
void jiechen(int v){
	for(int i = 1 ; i <= len ; i ++ )
		t[i] = t[i] * v;
		
	 int i=1;
	 while(t[i]>9||i<len)
	 {
	 	t[i+1]+=t[i]/10;
	 	t[i]%=10;
	 	i++;
	 }
	 len=i;
	
}
void add(){
	for(int i=1;i<=len;i++)
	{
		res[i]+=t[i];
		if(res[i]>9)
		{
			res[i+1]+=res[i]/10;
			res[i]%=10;
			reslen=max(reslen,i+1);
		}
		reslen=max(reslen,i);
	}
}
int main(){  
   std::ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin >> n;
    t[1] = 1;
    for(int i = 1 ; i <= n ; i++ ) jiechen(i),add();
    for(int i = reslen ; i >=1;i--)
    cout<<res[i];
	return 0;
}

E 高精度求积

【问题描述】

输入两个高精度正整数M和N（M和N均小于100位）。

求这两个高精度数的积。

【输入形式】

输入两个高精度正整数M和N。

【输出形式】

求这两个高精度数的积。

【样例输入】

36

3

【样例输出】

108


#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
# include<iostream>
# include<algorithm>
# include<cmath>
# include<cstdio>
# include<set>
# include<stack>
# include<queue> 
# include<map>
# include<string>
# include<cstring> 
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int > PII; 
const int mod=1e9+7;
const int MAX=2e6+10;
const int Time=86400;
const int X=131;
const int inf=0x3f3f3f3f;
const double PI = 1e-4;
double pai = 3.14159265358979323846; 

string s1,s2;
int a[MAX],b[MAX],c[MAX];
int len1,len2,len3;

int main(){  
   std::ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin >> s1 >> s2;
    if(s1[0] == '0' || s2[0] == '0'){
    	 cout<<0;
    	 return 0;
	}
	len1 = s1.length() ;
	len2 = s2.length() ;
	
	for(int i = 0 ; i < len1 ; i ++ )
	 a[len1 - i ] = s1[i] - '0';
	for(int i = 0 ; i < len2 ; i ++ )
	 b[len2 - i ] = s2[i] - '0';
	
	for(int i = 1 ; i <= len2 ; i++ ){
		 int k = 0;
		 for(int j = 1 ; j <= len1 ; j ++){
		 	c[i + j - 1] = a[j] * b[i] + c[i+j-1];
            k=c[i + j - 1]/10;
            c[i + j - 1]%=10;
            c[i + j] += k;
		 } 
	}
	
	len3=len1+len2;
    for(int j=len3;j>=1;j--)
    if(c[j]!=0) break;
     else len3--;
    for(int j=len3;j>=1;j--)
        cout<<c[j];
	return 0;
}

F 天使的起誓

【问题描述】

TENSHI非常幸运地被选为掌管智慧之匙的天使。在正式任职之前，她必须和其他新当选的天使一样，要宣誓。宣誓仪式是每位天使各自表述自己的使命，她们的发言稿被放在n 个呈圆形排列的宝盒中。这些宝盒按顺时针方向被编上号码1、2、3……、n-1、n。一开始天使们站在编号为N 的宝盒旁。她们各自手
上都有一个数字，代表她们自己的发言稿所在的盒子是从１号盒子开始按顺时针方向的第几个。例如：有７个盒子，那么如果TENSHI 手上的数字为9，那么她的发言稿所在盒子就是第2 个。现在天使们开始按照自己手上的数字来找发言稿，先找到的就可以先发言。TENSHI 一下子就找到了，于是她最先上台宣誓：“我将带领大家开启NOI 之门……”TENSHI 宣誓结束以后，陆续有天使上台宣誓。可是有一位天使找了好久都找不到她的发言稿，原来她手上的数字M 非常大，她转了好久都找不到她想找的宝盒。请帮助这位天使找到她想找的宝盒的编号。

【输入形式】

从文件 的第一、二行分别读入正整数n 和m，其中n、m 满足 2 ≤ n≤ 108，2 ≤ m≤ 101000

【输出形式】

把所求宝盒的编号输出，文件只有一行（包括换行符）。

【样例输入1】

7
9

【样例输出1】

2

【样例输入2】

11

108

【样例输出2】

9


#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
# include<iostream>
# include<algorithm>
# include<cmath>
# include<cstdio>
# include<set>
# include<stack>
# include<queue> 
# include<map>
# include<string>
# include<cstring> 
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int > PII; 
const int mod=1e9+7;
const int MAX=2e6+10;
const int Time=86400;
const int X=131;
const int inf=0x3f3f3f3f;
const double PI = 1e-4;
double pai = 3.14159265358979323846; 

int n;
ll ans ;
char s[MAX];

int main(){  
   std::ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    string s;
    cin >> n >> s;
  
    for(int i=0;s[i] ;i++) 
	 ans=(ans*10+s[i]-'0')%n;
	 
    if(ans == 0 ) cout<<n;
     else cout<<ans;
	return 0;
}

G Hanoi 双塔问题

【问题描述】

给定A、B、C 三根足够长的细柱，在A 柱上放有2n 个中间有孔的圆盘，共有n 个不同的尺寸，每个尺寸都有两个相同的圆盘，注意这两个圆盘是不加区分的（下图为n=3 的情形）。现要将这些圆盘移到C 柱上，在移动过程中可放在B 柱上暂存。要求：
（1）每次只能移动一个圆盘；
（2）A、B、C 三根细柱上的圆盘都要保持上小下大的顺序；任务：设An为2n个圆盘完成上述任务所需的最少移动次数，对于输入的n，输出An。

【输入形式】

输入文件为一个正整数n，表示在A 柱上放有2n 个圆盘。

【输出形式】

输出仅一行，包含一个正整数, 为完成上述任务所需的最少移动次数An。

【样例输入1】
1
【样例输出1】
2
【样例输入2】
2
【样例输出2】
6


#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
# include<iostream>
# include<algorithm>
# include<cmath>
# include<cstdio>
# include<set>
# include<stack>
# include<queue> 
# include<map>
# include<string>
# include<cstring> 
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int > PII; 
const int mod=1e9+7;
const int MAX=2e6+10;
const int Time=86400;
const int X=131;
const int inf=0x3f3f3f3f;
const double PI = 1e-4;
double pai = 3.14159265358979323846; 
int n ,a[205],b[205];
void gjc(){
	int t = 0,k;
	for(int j = 200 ; j > 0 ;j--){
		 k = b[j] * 2 + t;
		 b[j] = k % 10;
		 t = k / 10;
	}
}
void gjj(){
	int t = 0 ,k;
	for(int j = 200 ; j > 0 ; j-- ){
		 k = a[j] + b[j] + t;
		 a[j] = k % 10;
		 t = k / 10;
	}
}
int main(){  
   std::ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin >> n;
    b[200] = 1;
    for(int i = 1;i <= n ; i++) gjc(),gjj();
	
	int k = 1;
	while(a[k] == 0 && k < 200) k ++ ;
	for(int i = k ; i <= 200 ; i++ )
	 cout<<a[i]; 
	return 0;
}

H 高精除

【问题描述】

高精除以高精，求它们的商和余数。

【输入形式】

输入两个低于300位的正整数。

【输出形式】

输出商和余数。

【样例输入】

1231312318457577687897987642324567864324567876543245671425346756786867867867
1231312318767141738178325678412414124141425346756786867867867

【样例输出】

999999999748590
179780909068307566598992807564736854549985603543237528310337

#include <cstdio>
#include <iostream>
#include <cstring>
using namespace std;

int a[101], b[101], c[101], d;

void init(int a[]) {
	string s;
	cin >> s;						// 读入字符串s
	a[0] = s.length();				// 用a[0]计算字符串s的位数
	for (int i=1; i<=a[0]; i++) {
		a[i] = s[a[0]-i] - 48;		// 将数串s转换为数组a，并倒序存储 
	} 	
}

void print(int a[]) {				// 打印输出 
	if (a[0] == 0) {
		cout << 0 << endl;
		return;
	}
	for (int i=a[0]; i>=1; i--) {
		cout << a[i];
	}
	cout << endl;
	return;
} 

int compare(int a[], int b[]) {		// 比较a和b的大小关系，若a>b则为1，a<b则为-1，a=b则为0
	if (a[0] > b[0]) {
		return 1;
	} 
	if (a[0] < b[0]) {
		return -1;
	}
	for (int i=a[0]; i>=1; i--) {	// 从高位到低位比较 
		if (a[i] > b[i]) {
			return 1;
		} 
		if (a[i] < b[i]) {
			return -1;
		}
	} 
	return 0;						// 各位都相等则两数相等 
}

void numcpy(int p[], int q[], int det) {	// 复制p数组到q数组从det开始的地方 
	for (int i=1; i<=p[0]; i++) {
		q[i+det-1] = p[i];
	}
	q[0] = p[0] + det - 1;
}

void jian(int a[], int b[]) {			// 计算 a=a-b 
	int flag = compare(a, b);			// 调用比较函数判断大小 
	if (flag == 0)  {					// 相等 
		a[0] = 0;
		return;
	}
	if (flag == 1) {					// 大于 
		for (int i=1; i<=a[0]; i++) {
			if (a[i] < b[i]) {			 
				a[i+1]--;				// 若不够减，则向上借一位 
				a[i] += 10;
			}
			a[i] -= b[i];
		}
		while (a[0]>0 && a[a[0]]==0) {
			a[0]--;						// 修正a的位数 
		} 
		return; 
	}				 
}

void chugao(int a[], int b[], int c[]) {
	int tmp[101];
	
	c[0] = a[0] - b[0] + 1;
	for (int i=c[0]; i>0; i--) {
	
		memset(tmp, 0, sizeof(tmp));		// 数组清零
		numcpy(b, tmp, i);

		while (compare(a, tmp) >= 0) {
			c[i]++;
			jian(a, tmp);
								// 用减法来模拟 
		} 
	}
	while (c[0]>0 && c[c[0]]==0) {
		c[0]--;
	}
	return;
}

int main() {
	memset(a, 0, sizeof(a));
	memset(b, 0, sizeof(b));
	memset(c, 0, sizeof(c));
	
	init(a);
	init(b);
	 
	chugao(a,b,c);
	
	print(c);
	print(a);
	
	return 0;
}

I 回文数

【问题描述】

若一个数（首位不为零）从左向右读与从右向左读都是一样，我们就将其称之为回文数。例如：给定一个 10进制数 56，将 56加 65（即把56从右向左读），得到 121是一个回文数。又如，对于10进制数87，
STEP1： 87＋78= 165 STEP2： 165＋561= 726
STEP3： 726＋627＝1353 STEP4：1353+3531=4884
在这里的一步是指进行了一次N进制的加法，上例最少用了4步得到回文数4884。
写一个程序，给定一个N（2＜N＜＝10或N=16）进制数 M．求最少经过几步可以得到回文数。如果在30步以内（包含30步）不可能得到回文数，则输出“Impossible！” 。

【输入形式】

给定一个N（2＜N＜＝10或N=16）进制数M。

【输出形式】

最少几步。如果在30步以内（包含30步）不可能得到回文数，则输出“Impossible！”。

【样例输入】

9 87

【样例输出】

STEP=6


#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
# include<iostream>
# include<algorithm>
# include<cmath>
# include<cstdio>
# include<set>
# include<stack>
# include<queue> 
# include<map>
# include<string>
# include<cstring> 
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int > PII; 
const int mod=1e9+7;
const int MAX=2e6+10;
const int Time=86400;
const int X=131;
const int inf=0x3f3f3f3f;
const double PI = 1e-4;
double pai = 3.14159265358979323846; 

char c[305],d[305];
int n,step,len;

void add(){
	for(int i = 0 ; i < len ; i ++)
	 d[len - i - 1] = c[i];
	 
	 len += 2 ;
	for(int i = 0 ; i < len ; i ++ ){
		 c[i] += d[i];
		 if(c[i] >= n) c[i+1] ++, c[i] -= n;
	}
	while(!c[len - 1]) len -- ;
}

int judge(){
	for(int i = 0 ; i < len ; i ++){
		 if(c[i] != c[len - 1 - i]) return 0;
	}
	return 1;
	
}
int main(){  
   std::ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin >> n >> c;
    len = strlen(c);
    for(int i = 0 ; c[i] ; i ++ ){

    	 if(c[i] >='0' && c[i] <='9') c[i] -= '0';
    	  else  c[i] = c[i] - 'A' + 10;
    	  
	}
	while(!judge()){
		step++;
		if(step>30) break;
		add();
	}
	if(step <= 30) cout<<"STEP="<<step;
	 else cout<<"Impossible!";
	 
	return 0;
}
Myajlk
关注
专栏目录
Python 进阶（十一）：高精度计算（decimal 模块）
水滴的博客
11-26 7229
decimal模块提供了一种精确计算浮点数的方法，解决了浮点数精度问题。通过导入decimal模块、设置精度、创建Decimal对象、进行基本运算和比较运算，以及使用常用函数，我们可以实现精确的数值计算。在使用decimal模块时，需要注意保持一致使用Decimal对象，并避免除数为零的情况。
《Python基础教程》专栏总结篇
热门推荐
weixin_43178406的博客
10-11 19万+
今天给大家带来的文章是《Python基础教程》专栏总结篇，希望能对同学们有所帮助。 文章目录 1. 背景 2. 专栏亮点 3. 你的收获 4. 详细目录
求1+2!+3!+...+N!的和（高精度）
Sega_hsj 's Blog
10-25 886
如果n很大的话，即使用long long 也存不下，所以使用了数组来完成这道题。//可以算到500位#include<string> #include<stdio.h> #include<string.h> #include<iostream> #include<map> using namespace std; int num[501]; //存放n！的数组 int result[501];//
C语言高精度运算-阶乘累加：1!+2!+3!+...+n!
Yl
04-23 4231
/* 高精度运算-阶乘累积求和 1+2!+3!...+n! */ # include <stdio.h> # define N 10000 // 数组长度 int main(){ int i, j, k, n, s[N] = { 1 }, a[N] = { 1 }, digit = 1; // s累加和， a累积求阶乘， digit代表的是数字的位数 printf("Plea...
c语言用高精度计算出s=1!+2!+3!+…+n!(n≤50),c语言阶乘之和问题示例详解
weixin_39536630的博客
05-20 4033
题目描述用高精度计算出S=1！+2！+3！+…+n！(n≤50)其中“！”表示阶乘，例如：5！=5*4*3*2*1。输入输出格式输入格式：一个正整数N。输出格式：一个正整数S，表示计算结果。输入输出样例输入样例3输出样例9#includeint fun(int n){if(n==1||n==0){return 1;}if(n>1){return fun(n-1)*n;}}int main()...
用高精度计算出S=1!+2!+3!+…+n! (n≤50)（大数加法加大数阶乘）
Ripcord丶的博客
06-02 1万+
题目描述 用高精度计算出S=1!+2!+3!+…+n! (n≤50)S=1!+2!+3!+…+n!(n≤50) 输入 一个正整数N。 输出 一个正整数S，表示计算结果。 样例输入 3 50 样例输出 9 31035053229546199656252032972759319953190362094566672920420940313 题意解析 就是大数阶乘和大数加法...
c语言用高精度计算出s=1!+2!+3!+…+n!(n≤50),ACM 阶乘之和
weixin_35725147的博客
05-20 2913
【ACM 阶乘之和】的更多相关文章阶乘之和 时间限制:3000ms | 内存限制:65535KB 难度:3 描述 给你一个非负数整数n,判断n是不是一些数(这些数不允许重复使用,且为正数)的阶乘之和,如9=1!+2!+3!,如果是,则输出Yes,否则输出No: 输入 第一行有一个整数0阶乘之和 时间限制:3000ms | 内存限制:65535KB 难度:3 描述 给你一...
Linux时间子系统之六：高精度定时器（HRTIMER）的原理和实现 - DroidPhone的专栏 - 博客频道 - CSDN
08-03
Linux时间子系统中的高精度定时器（High Resolution Timer，简称HRTIMER）是为了解决传统低分辨率定时器精度不足的问题而引入的。在Linux内核2.6.16版本之后，高精度定时器被引入，以提供纳秒级别的定时精度，这在对...
C++处理大数问题/高精度问题,看这就够了
北北北
07-28 1万+
将带你了解 1.大数加法 2.大数减法 3.辨识负数的大数加减法 4.大数乘法 5.大数除法
如何写好付费专栏之开宗明义篇
herosunly的博客
04-09 12万+
本文主要介绍了写好付费专栏的开宗明义篇，希望对学习博客写作的同学们有所帮助。 文章目录 1. 开设本专栏的动机 2. 课程大纲
计算1！+2！+3！……+n!。
XG17_38241417145的博客
11-14 1万+
#include<stdio.h> main() {      int i,j,n;      long p,sum=0;      printf("Input n:");      scanf("%d",&n);      for(i=1;i<=n;i++)      {          p=1;
编程计算1!+2!+3!+…+N!
辣鸡小客
04-20 4万+
编程计算1!+2!+3!+…+N! 。N由用户输入。 程序运行结果如下： 输入：10输出：4037913分析：计算阶乘之和，说明一下我的方法，用变量t做计数器，计算到i时（还未进行计算）,此时t的值是（i-1）!，进行计算后，t就变成了i！，也就是说不需要双层for循环每次计算一个阶乘的……（顺便吐槽一下某个用双层for循环的朋友……我给你个1000W的数据规模……1s你解决不了问题的……）for...
高精度乘法（高精度计算）
wodemaoheise的博客
04-22 763
描述 输入两个高精度正整数M和N（M和N均小于100位）。求这两个高精度数的积。 格式 输入格式 输入两个高精度正整数M和N。 输出格式 求这两个高精度数的积。 样例 输入样例 36 3 输出样例 108 限制 时间限制: 1000 ms 内存限制: 65536 KB #include<bits/stdc++.h> using namespac...
蓝桥杯总结与练习(一）模拟与高精度(包括日期相关算法)
huangshiyu123456的博客
02-23 1315
(一)模拟与高精度   想必大家都听说过“数学建模”这个东西，模拟其实也不难，相当于“计算机建模”，就是用计算机代码去模拟一些事件或规律，而这些规律题目已经直接过着间接得告诉你了，我们通常通过for循环和if判断就可以把事件或规律模拟出来了。   根据规律，我大致分类以下三类问题：（1）简单模拟问题 。(2)高精度计算问题。(3)日期模拟问题 (1)简单模拟问题   这类问题呢，也很简单，题目怎么 “说”，我们就怎么做，注意 “说”,可能题目不会直接告诉你规律，你可能需要观察输出来找到题目所 “说” 的规律
2818 天使的起誓
CCCCDEV_CCCC的博客
05-27 256
2818 天使的起誓 这道题本来是想拿同余练练手 其实这道题就是取余的定义，用人话来说，其实就是从这n个里面寻找，取余就好
1307：【例1.3】高精度乘法
zqhf123的博客
03-03 767
1307：【例1.3】高精度乘法 时间限制: 1000 ms 内存限制: 65536 KB 提交数: 20004 通过数: 6836 【题目描述】 输入两个高精度正整数M和N（M和N均小于100位）。求这两个高精度数的积。 【输入】 输入两个高精度正整数M和N。 【输出】 求这两个高精度数的积。 【输入样例】 36 3 【输出样例】 108 思路：高精度乘法 #inclu...
高精度算法之累加
小Tian的博客
03-31 3135
Description 用高精度方法，求s=1+2+3+……+n的精确值(n以一般整数输入)。 Input 一行一个整数n（<1000000） Output 输出1到n的累加和，一组数据占一行 Sample Input 10 Sample Output 55 思路:两个大数字相加,用一个数组来存放它们每一位的和,然后考虑进位,这个题稍微变了一...
一本通 1616：A 的 B 次方
07-02 202
A 的 B 次方 快速幂板子题 Code： #include <iostream> #include <cstdio> #include <cmath> #include <cstring> using namespace std; //Mystery_Sky // #define M 1000100 #define ll long lo...
Matlab界面面板版车牌识别系统设计实现[Matlab界面面板版].zip
最新发布
10-20
zip
springboot 专栏
09-07
您好！欢迎来到CSDN开发的聊天AI助手"C知道"。我可以为您提供关于Spring Boot的专栏资源。以下是一些值得推荐的Spring Boot专栏： 1.《Spring Boot实战》：该专栏由CSDN的专家编写，涵盖了Spring Boot的基础知识、核心组件、常用功能和实际应用场景等内容。您可以在CSDN平台搜索该专栏获得更多详细信息。 2.《深入浅出Spring Boot》：这是一系列文章，由一位经验丰富的开发者撰写，详细介绍了Spring Boot的原理和内部机制，帮助您深入理解框架的工作原理。 3.《Spring Boot项目实战》：这个专栏是一个系列教程，通过步骤指导您从零开始构建一个完整的Spring Boot项目。您将学习如何配置数据库、集成其他框架、处理HTTP请求和响应等。 4.《Spring Boot框架原理与实战》：该专栏主要介绍了Spring Boot框架的设计思想、核心组件和常见问题解决方案。适合对框架底层原理感兴趣的开发者。 希望以上专栏资源可以帮助您更好地学习和应用Spring Boot技术。如果您有其他问题，还请告诉我，我将竭诚为您提供帮助！
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值