精华内容
下载资源
问答
  • 蓝桥杯 阶乘计算

    2019-10-31 16:59:42
    蓝桥杯 阶乘计算 题目 问题描述  输入一个正整数n,输出n!的值。  其中n!=123*…*n。 算法描述  n!可能很大,而计算机能表示的整数范围有限,需要使用高精度计算的方法。使用一个数组A来表示一个大整数a,A[0]...

    蓝桥杯 阶乘计算

    题目

    问题描述
      输入一个正整数n,输出n!的值。
      其中n!=123*…*n。
    算法描述
      n!可能很大,而计算机能表示的整数范围有限,需要使用高精度计算的方法。使用一个数组A来表示一个大整数a,A[0]表示a的个位,A[1]表示a的十位,依次类推。
      将a乘以一个整数k变为将数组A的每一个元素都乘以k,请注意处理相应的进位。
      首先将a设为1,然后乘2,乘3,当乘到n时,即得到了n!的值。
    输入格式
      输入包含一个正整数n,n<=1000。
    输出格式
      输出n!的准确值。
    样例输入
    10
    样例输出
    3628800

    #include<stdio.h>
    int main()
    {
    	int n,i,j,k,temp,count=9999,a[10000];
    	for(k=0;k<10000;k++)
    	a[k]=0;//初始化数组所有的数为0
    	scanf("%d",&n);
    	a[0]=1;
    	for(j=1;j<=n;j++)
    	{
    		for(i=0;i<10000;i++)
    	    {
    	    	a[i]=a[i]*j;
    	    }
    	    for(i=0;i<10000;i++)
    	    {
    	    	while(a[i]>=10)//进位的处理
        		{
        		temp=a[i];
        		a[i]=a[i]%10;
    			a[i+1]+=temp/10;
    			}
    		}
    	}
    	for(i=9999;i>=0;i--)
    	{
    		if(a[i]==0)
    		count--;
    		if(a[i]!=0)
    		break;		
    	}
    	for(j=count;j>=0;j--)
    	printf("%d",a[j]);
    	return 0;
    } 
    
    
    展开全文
  • 蓝桥杯阶乘计算

    2018-01-02 22:09:47
    基础练习 阶乘计算 时间限制:1.0s 内存限制:512.0MB 问题描述 输入一个正整数n,输出n!的值。 其中n!=1*2*3*…*n。算法描述 n!可能很大,而计算机能表示的整数范围有限,需要使用高精度计算的方法。使用一个...

      基础练习 阶乘计算  
    时间限制:1.0s   内存限制:512.0MB
          
    问题描述
      输入一个正整数n,输出n!的值。
      其中n!=1*2*3*…*n
    算法描述
      n!可能很大,而计算机能表示的整数范围有限,需要使用高精度计算的方法。使用一个数组A来表示一个大整数aA[0]表示a的个位,A[1]表示a的十位,依次类推。
      将a乘以一个整数k变为将数组A的每一个元素都乘以k,请注意处理相应的进位。
      首先将a设为1,然后乘2,乘3,当乘到n时,即得到了n!的值。
    输入格式
      输入包含一个正整数nn<=1000。
    输出格式
      输出n!的准确值。
    样例输入
    10
    样例输出
    3628800

    #include<iostream>
    using namespace std;
    int a[1000000]={0};
    int main()
    {int n,s,c,t;
    while(cin>>n)
        {
            c=0;a[0]=1;
            for(int i=1;i<=n;i++)
            {
                for(int j=0;j<100000;j++)
                {
                    s=a[j]*i+c;
                    a[j]=s%10;
                    c=s/10;
                }
            }
            for(int j=99999;j>=0;j--)
            {
                if(a[j])
                    {
                        t=j;break;
                    }
            }
            for(int j=t;j>=0;j--)
            {
                cout<<a[j];
            }
            cout<<endl;
        }
        return 0;
    }

    展开全文
  • 可能很大,而计算机能表示的整数范围有限,需要使用高精度计算的方法。使用一个数组A来表示一个大整数a,A[0]表示a的个位,A[1]表示a的十位,依次类推。  将a乘以一个整数k变为将数组A的每一个元素都乘以k,请注意...

    资源限制
    时间限制:1.0s 内存限制:512.0MB
    问题描述
      输入一个正整数n,输出n!的值。
      其中n!=123*…*n。
    算法描述
      n!可能很大,而计算机能表示的整数范围有限,需要使用高精度计算的方法。使用一个数组A来表示一个大整数a,A[0]表示a的个位,A[1]表示a的十位,依次类推。
      将a乘以一个整数k变为将数组A的每一个元素都乘以k,请注意处理相应的进位。
      首先将a设为1,然后乘2,乘3,当乘到n时,即得到了n!的值。
    输入格式
      输入包含一个正整数n,n<=1000。
    输出格式
      输出n!的准确值。
    样例输入
    10
    样例输出
    3628800

    解题思路:
    该题的思路与上一题高阶加法差不多,都是还原算数最原始的样子:按位运算并进位,这次 我参考了一位大佬的算法,比我之前的一位一位存储要高明得多,这次是一次存储四位,如有进位在数祖下一位进位,代码的注释很详细,需要注意输出的时候要进行判断,除了最高位的数组位不一定为4位,其他位数都是要4位。Ok,这便是基础练习的最后一题,让我们来看看代码吧!

    #include <bits/stdc++.h>
    using namespace std;
    #define N 10000
    int main()
    {
    	int a[N] = {1};			// 一个数组A来表示一个大整数a,将a设为1,方便进行运算 
    	int k = 0, l = 1, n;			 //k表示进位的数字,l表示数组元素个数(位数),n表示要计算的阶乘 
    	int i, j;
    	cin >> n;
    	for(i = 1;i <= n; i++)		//阶乘(不用递归可能怕消耗太大) 
    	{
    		for(j = 0; j < l; j++)	//数组A的每一个元素都乘以一个整数(正常的按位乘法) 
    		{
    			a[j] = a[j] * i + k;	//乘法计算,乘以i,类似算术里的竖式计算(加上上一位进位的数字) 
    			k = a[j] / 10000;	//每位存 10000 以内的数,否则进位
    			a[j] = a[j] % 10000;//保留余数 
    		}
    		if(k > 0)				//最后一位进位的处理 
    		{
    			a[j] = k;			//把进位的数字存放在下一个数组元素中 (进位) 
    			l ++;			//数组长度加1 (增加一位) 
    			k = 0;			//重置k (进位完成) 
    		}
    	}
    	cout << a[l - 1];	//先输出最大位的数字(最大位可能不够4个数字) 如320输出一定还是320 
    	for(i = l-2; i >= 0; i --)	{//再输出之后位的数字 (一定每位有4个数字) 
    		if (a[i] / 1000 == 0 && a[i] /100 > 0) {
    			cout << "0" << a[i];
    		} 
    		else if (a[i] / 100 == 0 && a[i] /10 > 0) {
    			cout << "00" << a[i];
    		}
    		else if (a[i] / 10 == 0 && a[i] >= 0) {
    			cout << "000" << a[i];
    		}
    		else cout << setw(4) << a[i];//输出4位数字,空位用0补充。比如320输出为0320 
    	}
    	return 0;
    }
    

    这是参考的代码地址: https://blog.csdn.net/qq_40977710/article/details/80499140

    展开全文
  • 可能很大,而计算机能表示的整数范围有限,需要使用高精度计算的方法。 使用一个数组A来表示一个大整数a,A[0]表示a的个位,A[1]表示a的十位,依次类推。 将a乘以一个整数k变为将数组A的每一个元素都乘以k,请注意...

    1.题目描述

    输入一个正整数n,输出n!的值。
    其中n!=123*…*n。
    算法描述
    n!可能很大,而计算机能表示的整数范围有限,需要使用高精度计算的方法。
    使用一个数组A来表示一个大整数a,A[0]表示a的个位,A[1]表示a的十位,依次类推。
    将a乘以一个整数k变为将数组A的每一个元素都乘以k,请注意处理相应的进位。
    首先将a设为1,然后乘2,乘3,当乘到n时,即得到了n!的值。
    输入 输入包含一个正整数n,n< = 1000。
    输出 输出n!的准确值。
    样例输入 10
    样例输出 3628800

    2.思路

    刚开始自己写了很多乱七八糟的方法,还写不出来,还有主要没理解透进位写法的妙处。然后在网上搜了一下,发现普遍都是下面这种方法,自己看了下,然后写了一遍。由于很久之前卡在这题,然后就过年没看了,参考文章也不知道具体是哪篇了,就不放链接了。记录一下代码

    import java.util.Scanner;
    public class FactorialCalculation {
    
    	public static void main(String[] args) {
    		Scanner sc = new Scanner(System.in);
    		int n = sc.nextInt();
    		factorial(n);
    	}
    	public static void factorial(int n) {
    		int temp;//存储临时结果
    		int jinwei = 0;//进制
    		int[] a = new int[9999];
    		a[0] = 1;//代表个位
    		for(int i = 2; i <= n; ++i) {//第一层循环是从1到n,表示阶乘的每一项,因为已经让a[0]等于1了,从2开始即可
    			for(int j = 0; j < a.length; ++j) {//第二层循环是计算阶乘的结果,因为不知道进位的情况,所以不能判断计算结果会存储到哪一位,就只能让0累加到9998
    				temp = a[j] * i + jinwei;//必须要加上jinwei,非常巧妙
    				a[j] = temp % 10;
    				jinwei = temp / 10;
    				
    			}
    		}
    //		将数组倒序输出即得到结果
    		int notZeroStart = 0;
    		for(int i = a.length - 1; i >= 0 ; --i) {
    			if(a[i] != 0) {//遇到第一个不为0的时候就要开始全部输出
    				notZeroStart = i ;//记录非零位置
    				break;//别忘了break;
    			}
    		}
    	for(int i = notZeroStart; i >= 0; --i) {
    		System.out.print(a[i]);
    	}
    }
    }
    

    然后经过这道题的熏陶,又刷到了一道类似题,在我深刻参悟刚才那道题之后,然后做起来就轻松了

    3.题目描述

    输入两个整数a和b,输出这两个整数的和。a和b都不超过100位。
    算法描述
    由于a和b都比较大,所以不能直接使用语言中的标准数据类型来存储。对于这种问题,一般使用数组来处理。
    定义一个数组A,A[0]用于存储a的个位,A[1]用于存储a的十位,依此类推。同样可以用一个数组B来存储b。
    计算c = a + b的时候,首先将A[0]与B[0]相加,如果有进位产生,则把进位(即和的十位数)存入r,把和的个位数存入C[0],即C[0]等于(A[0]+B[0])%10。然后计算A[1]与B[1]相加,这时还应将低位进上来的值r也加起来,即C[1]应该是A[1]、B[1]和r三个数的和.
    如果又有进位产生,则仍可将新的进位存入到r中,和的个位存到C[1]中。依此类推,即可求出C的所有位。最后将C输出即可。
    输入
    输入包括两行,第一行为一个非负整数a,第二行为一个非负整数b。两个整数都不超过100位,两数的最高位都不是0。
    输出
    输出一行,表示a + b的值。
    样例输入
    20100122201001221234567890
    2010012220100122
    样例输出
    20100122203011233454668012

    4.代码

    import java.util.Scanner;
    public class HighPrecisionAddition {
    
    	public static void main(String[] args) {
    		Scanner sc = new Scanner(System.in);
    		//a和b都不超过100位。此时已经不能用int存储了
    		String a = sc.next();
    		String b = sc.next();
    		add(a,b);
    	}
    
    	private static void add(String a, String b) {
    		//定义三个数组
    		int[] A = new int[100];
    		int[] B = new int[100];
    		int[] C = new int[9999];
    		//先将a,b用数组储存起来
    		int j = 0;//为了个位在A[0]处存储
    		for(int i = a.length() - 1; i >= 0; --i) {
    			A[j] = Integer.valueOf(a.substring(i, i+1)).intValue();
    			j += 1;
    		}
    		j = 0;
    		for(int i = b.length() - 1; i >= 0; --i) {
    			B[j] = Integer.valueOf(b.substring(i, i+1)).intValue();
    			j += 1;
    		}//存储结束
    		int tempRes;//存储临时结果
    		int jinwei = 0;//保存进位
    		int lengthBigger = 0;//记录A,B数组中更长的一组的长度
    		if(A.length > B.length) {
    			lengthBigger = A.length;
    		} else {
    			lengthBigger = B.length;
    		}
    		//开始进行计算
    		for(int m = 0; m < lengthBigger; ++m) {
    			tempRes = A[m] + B[m] + jinwei;
    			C[m] = tempRes % 10;
    			jinwei = tempRes / 10;
    		}
    		//最后逆序输出得到答案
    		int notZeroIndex = 0;//先找到非零位
    		for(int i = C.length - 1; i >= 0; --i) {
    			if(C[i] != 0) {
    				notZeroIndex = i;
    				break;
    			}
    		}
    		for(int i = notZeroIndex; i >= 0; --i) {
    			System.out.print(C[i]);
    		}	
    	}
    }
    

    5.参考文章

    复制一个方法:int与String之间的互相转换,老是忘记:
    来源:link.
    1 如何将字串 String 转换成整数 int?
    A. 有两个方法:
    1、 int i = Integer.parseInt([String]); 或 i = Integer.parseInt([String],[int radix]);
    2、 int i = Integer.valueOf(my_str).intValue();
    注: 字串转成 Double, Float, Long 的方法大同小异.

    2 如何将整数 int 转换成字串 String ?
    A. 有叁种方法:

    1、String s = String.valueOf(i);
    2、String s = Integer.toString(i);
    3、String s = “” + i;
    注: Double, Float, Long 转成字串的方法大同小异.

    int -> String
    int i=12345;

    String s="";

    第一种方法:s=i+"";

    第二种方法:s=String.valueOf(i);

    这两种方法有什么区别呢?作用是不是一样的呢?是不是在任何下都能互换呢?

    String -> int
    s=“12345”;

    int i;

    第一种方法:i=Integer.parseInt(s);

    第二种方法:i=Integer.valueOf(s).intValue();

    这两种方法有什么区别呢?作用是不是一样的呢?是不是在任何下都能互换呢?

    以下是答案:

    第一种方法:s=i+""; //会产生两个String对象

    第二种方法:s=String.valueOf(i); //直接使用String类的静态方法,只产生一个对象

    第一种方法:i=Integer.parseInt(s); //直接使用静态方法,不会产生多余的对象,但会抛出异常

    第二种方法:i=Integer.valueOf(s).intValue(); //Integer.valueOf(s) 相当于 new Integer(Integer.parseInt(s)),也会抛异常,但会多产生一个对象

    6.学习心得:多积累,高精度加法肯定不是最好的算法,但这是自己动脑壳写出来的题。

    展开全文
  • 给定 n,要求计算 n!,直接用C/C++标准类型int/long long存不下,想要用数组,数组的一个单元表示阶乘结果的一位。 #include &lt;iostream&gt; #include &lt;cstdio&gt; #include &lt;...
  • 蓝桥杯——阶乘计算

    2021-01-28 20:37:18
    蓝桥杯——阶乘计算 vip Java BigInteger multiplyByInt 大数乘法
  • 可能很大,而计算机能表示的整数范围有限,需要使用高精度计算的方法。使用一个数组A来表示一个大整数a,A[0]表示a的个位,A[1]表示a的十位,依次类推。  将a乘以一个整数k变为将数组A的每一个元素都乘以k,请注意...
  • 蓝桥杯阶乘算法

    2021-02-25 13:23:16
    阶乘 问题描述 输入一个正整数n,输出n!的值。 其中n!=123*…*n。 算法描述 n!可能很大,而计算机能表示的整数范围有限,需要使用高精度计算的方法。使用一个数组A来表示一个大整数a,A[0]表示a的个位,A[1]表示a的...
  • 蓝桥杯——阶乘计算。关键在于进位的问题,不能使用判断。
  • 蓝桥杯阶乘计算

    2018-03-20 11:15:30
    蓝桥杯:基础练习 阶乘计算看到阶乘我的第一反应肯定是用递归进行计算,但是我还忘了蓝桥杯经常出那种变态数据,所以我毫无意外的落坑了;仔细看了一下题目,竟然还有提示,那就按照提示的来做,贴代码:#include&...
  • java实现第七届蓝桥杯阶乘位数

    万次阅读 多人点赞 2019-07-29 18:15:24
    请你计算,9999 的阶乘的二进制表示一共有多少位? 注意:需要提交的是一个整数,不要填写任何无关内容(比如说明解释等) 答案:118445 import java.math.BigInteger; public class Main { pub...
  • 蓝桥杯python 阶乘计算

    2020-08-06 17:24:40
    基础训练BASIC-30 阶乘计算 问题描述  输入一个正整数n,输出n!的值。  其中n!=123*…*n。 算法描述  n!可能很大,而计算机能表示的整数范围有限,需要使用高精度计算的方法。使用一个数组A来表示一个大整数a,A...
  • java实现第四届蓝桥杯阶乘位数

    万次阅读 多人点赞 2019-07-29 16:37:15
    阶乘位数 题目描述 小明刚刚看完电影《第39级台阶》,离开电影院的时候,他数了数礼堂前的台阶数,恰好是39级! 站在台阶前,他突然又想着一个问题: 如果我每一步只能迈上1个或2个台阶。先迈左脚,然后左右交替,...
  • 蓝桥杯 Java 阶乘计算

    2020-07-30 17:34:48
    所以想要计算阶乘就需要用到数组来进行高精度的计算。 用数组a来表示一个整数A,a[0] 表示A的个位,a[1] 表示A的十位。(这里采用的是逆序存储的方法,因为逆序存储在进行进位操作的时候比较方便) 话不多说,上代码...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 445
精华内容 178
关键字:

蓝桥杯阶乘计算