阶乘运算
//阶乘各算法的 C++ 类实现
#include
#include
#include
#include
using namespace std;
class Factorial {
static const int MAXN = 5001; // 最大阶乘数，实际用不到这么大int *data[MAXN]; // 存放各个数的阶乘
int *nonzero; // 从低位数起第一个非0数字
int maxn; // 存放最大已经计算好的n的阶乘int SmallFact(int n); // n <= 12的递归程序
void TransToStr(int n, int *s); // 将数n倒序存入数组中
void Multply (int* A, int* B, int* C, int totallen); // 执行两个高精度数的乘法public:
Factorial();
~Factorial();
void Calculate(int n); // 调用计算阶乘
int FirstNonZero(int n); // 返回阶乘末尾第一个非0数字int CountZeros(int n); // 返回阶乘末尾有多少个0
int SecondNum(int n); // 返回阶乘左边的第二个数字
bool CanDivide(int m, int n); // 判断数值 m 是否可以整除 n!
void Output(int n) const;
};
int Factorial::SmallFact(int n) {
if (n == 1 || n == 0) return 1;
return SmallFact(n-1)*n;
}
void Factorial::TransToStr(int n, int *tmp) {
int i = 1;
while (n) {
tmp[i++] = n%10;
n /= 10;
}
tmp[0] = i-1;
}
void Factorial::Multply (int* A, int* B, int* C, int totallen)
{
int i, j, len;
memset(C, 0, totallen*sizeof(int));
for (i = 1; i <= A[0]; i++)
for (j = 1; j <= B[0]; j++) {
C[i+j-1] += A[i]*B[j]; // 当前i+j-1位对应项 + A[i] * B[j]
C[i+j] += C[i+j-1]/10; // 它的后一位 + 它的商（进位）
C[i+j-1] %= 10; // 它再取余即可
}
len = A[0] + B[0];
while (len > 1 && C[len] == 0 ) len--; // 获得它的实际长度
C[0] = len;
}
Factorial::Factorial() { // 构造函数，先把<=12的阶乘计算好
maxn = 12; data[0] = new int [2];
data[0][0] = 1; data[0][1] = 1;
int i, j = 1;
for (i = 1; i <= 12; i++) {
data[i] = new int [12];
j = j*i;
TransToStr(j, data[i]);
}
nonzero = new int [10*MAXN];
nonzero[0] = 1; nonzero[1] = 1; // nonzero[0]存储已经计算到的n!末尾非0数}
Factorial::~Factorial() {
for (int i = 0; i <= maxn; i++)
delete [] data[i];
delete [] nonzero;
}
void Factorial::Calculate(int n) {
if (n > MAXN) return;
if (n <= maxn) return; // <= maxn的，已经在计算好的数组中了int i, j, len;
int tmp[12];
for (i = maxn+1; i <= n; i++) {
TransToStr(i, tmp);
len = data[i-1][0] + tmp[0] + 1;
data[i] = new int [len+1];
Multply(data[i-1], tmp, data[i], len+1);
}
maxn = n;
}
int Factorial::FirstNonZero(int n) {
if (n >= 10*MAXN) {
cout << "Super Pig, your input is so large, cannot Calculate. Sorry! ";
return -1;
}
if (n <= nonzero[0]) return nonzero[n]; //已经计算好了，直接返回
int res[5][4] = {{0,0,0,0}, {2,6,8,4}, {4,2,6,8}, {6,8,4,2}, {8,4,2,6}};
int i, five, t;
for (i = nonzero[0]+1; i <= n; i++) {
t = i;
while (t%10 == 0) t /= 10; // 先去掉 i 末尾的 0，这是不影响的
if (t%2 == 0) { // t是偶数直接乘再取模10即可
nonzero[i] = (nonzero[i-1]*t)%10;
}
else { // 否则转换成 res 数组来求
five = 0;
while (t%5 == 0) {
if (five == 3) five = 0;
else five++;
t /= 5;
}
nonzero[i] = res[((nonzero[i-1]*t)%10)/2][five];
// (nonzero[i-1]*t)%10/2 正好序号为：1, 2, 3, 4 中的一个
}
}
nonzero[0] = n;
return nonzero[n];
}
/* 阶乘末尾有多少个0，实际上只与5的因子数量有关，即求 n/5+n/25+n/625+...... */ int Factorial::CountZeros(int n) {
if (n >= 2000000000) {
cout << "Super Pig, your input is so large, cannot Calculate. Sorry! ";
return -1;
}
int cnt = 0;
while (n) {
n /= 5;
cnt += n;
}
return cnt;
}
/* 输出N!左边第二位的数字：用实数乘，超过100就除以10，最后取个位即可 */
int Factorial::SecondNum(int n) {
if (n <= 3) return 0;
int i;
double x = 6;
for (i = 4; i <= n; i++) {
x *= i;
while (x >= 100) x /= 10;
}
return (int(x))%10;
}
bool Factorial::CanDivide(int m, int n) {
if (m == 0) return false;
if (n >= m) return true;
int nn, i, j, nums1, nums2;
bool ok = true;
j = (int)sqrt(1.0*m);
for (i = 2; i <= j; i++) {
if (m%i == 0) {
nums1 = 0; // 除数m的素因子i的数量
while (m%i == 0) {
nums1++;
m /= i;
}
nums2 = 0; nn = n;
while (nn) { // 求 n 含有 i 因子的数量
nn /= i;
nums2 += nn;
}
if (nums2 < nums1) { // 少于m中所含i的数量，则m肯定无法整除n! ok = false;
break;
}
j = (int)sqrt(1.0*m); // 调整新的素因子前进范围
}
}
if (!ok || m > n || m == 0) return false;
else return true;
}
void Factorial::Output(int n) const {
if (n > MAXN) {
cout << "Super Pig, your input is so large, cannot Calculate. Sorry! ";
return;
}
int i, len = 8;
cout << setw(4) << n << "! = "; // 格式控制输出
for (i = data[n][0]; i >= 1; i--) {
cout << data[n][i];
if (++len == 58) { // 实际每输出50个字符就换行
len = 8;
cout << " ";
}
}
if (len != 8) cout << endl;
}
int main() {
int n, m, i;
Factorial f;
while (cin >> n) {
f.Calculate(n);
f.Output(n);
cout << "该阶乘末尾第一个非0数字是: " << f.FirstNonZero(n) << endl; cout << "该阶乘总共拥有数字0的个数：" << f.CountZeros(n) << endl; cout << "该阶乘的左边的第2位数字是：" << f.SecondNum(n) << endl; cin >> m;
if (f.CanDivide(m, n)) cout << m << " 可以整除 " << n << "! ";
else cout << m << " 不能整除 " << n << "! ";
}
return 0;
}
//第2部分第(5)个算法的单独实现
#include
int A[10] = {1,1,2,6,24,120,720,5040,40320,362880};
int ans[1024];
int sum;
void insert(int* a, int x) { // 插入排序，插成有序表int i, j;
for (i = 1; i <= a[0]; i++)
if (a[i] >= x) break;
if (i <= a[0] && a[i] == x) return; // 如果相等，则不用插入
if (i > a[0]) {
a[++a[0]] = x;
}
else {
for (j = a[0]++; j >= i; j--)
ans[j+1] = ans[j];
ans[i] = x;
}
if (a[0] == 1023) printf(" Array Overflow! ");
}
void search(int n){
for (int i = n; i <= 9; i++){
sum += A[i]; if (sum > 1) insert(ans, sum);
if (i < 9) search(i+1);
sum -= A[i];
}
}
int main(){
int n,i;
ans[0] = 1; ans[1] = 1; //初始化ans数组，ans[0]表示表长
search(0);
//printf("len = %d ", ans[0]);
while(1){
scanf("%d",&n);
if(n < 0)break;
if(n > 409114){ printf("NO ");continue;}
for (i = 1; i <= ans[0]; i++)
if (ans[i] == n) {printf("YES "); break;}
else if (ans[i] > n) {printf("NO "); break;}
}
return 0;
}
//
阶乘相关算法及程序
有关阶乘的算法，不外乎两个方面：一是高精度计算；二是与数论相关。
一. 高精度计算阶乘
这实际上是最没有技术含量的问题，但是又会经常用到，所以还是得编写，优化它的计算。
首先看小于等于12的阶乘计算(计算结果不会超出32位范围):
int factorial(int n) {
if (n == 1 || n == 0) return 1;
return factorial(n-1)*n;
}
这个递归程序简单明了，非常直观，然而一旦n > 12，则超过32位int型的范围出现错误结果，所以上面这个递归程序仅适合n <= 12
（其中A * B = C，的阶乘计算，为了计算较大n的阶乘，需要将高精度乘法算法纳入到阶乘计算中来，高精度乘法过程可以如下简单的描述：
A[0], B[0], C[0]分别存储长度）
for (i = 1; i <= A[0]; i++)
for (j = 1; j <= B[0]; j++) {
C[i+j-1] += A[i]*B[j]; // 当前i+j-1位对应项 + A[i] * B[j]
C[i+j] += C[i+j-1]/10; // 它的后一位 + 它的商（进位）
C[i+j-1] %= 10; // 它再取余即可
}
C[0] = A[0] + B[0];
while (C[0] > 1 && C[C[0]] == 0) C[0]--; // 去头0，获得实际C的长度
有了这个高精度乘法之后，计算阶乘就可以简单的迭代进行：
for (i = 2; i <= n; i++) {
将i转换成字符数组;
执行高精度乘法：将上一次结果乘上i
}
二. 与数论有关
由于阶乘到后面越来越大，巧妙的利用数论求得一些有趣的数字（数值）等成为阶乘算法的设计点，下面给出几道相关的问题与分析：(1) 计算阶乘末尾第一个非0数字：
这是一个比较经典的问题，比较复杂的算法是利用一个艰难的数学公式，可惜我不会，从网上的资料学习中，整理出下面这个简单易懂的算法：
观察n!，可以发现在乘的过程中，对于任意 n > 1，n!的末尾第一个非0数字都是偶数。我们只需保留最后一位非零数。当要乘的数中含有因数5时，我们可以把所有的因数5都当作8来乘。这是因为:
...x2*5=...10（舍）或...60，最后一位非零数为6。而恰好2*8=16，末位为6。
...x4*5=...70（舍）或...20，最后一位非零数为2。而恰好4*8=32，末位为2。
...x6*5=...30（舍）或...80，最后一位非零数为8。而恰好6*8=48，末位为8。
...x8*5=...90（舍）或...40，最后一位非零数为4。而恰好8*8=64，末位为4。
(对于n > 1时，最后一位不会出现 1, 7, 3, 9，而永远是2, 4, 6, 8的循环出现)
因此，在迭代作乘法时，主要就是计算因子5的数量，同时可见因子5的个数以4为循环节（即只需要取它的数量对4取模）。那么对于不同情况下的因子5的数量，可以通过res[5][4] = {{0,0,0,0}, {2,6,8,4}, {4,2,6,8}, {6,8,4,2}, {8,4,2,6}}来得到，使用nonzero[i]表示i 的阶乘的最后一位，那么：
如果t是偶数，则直接乘：nonzero[i] = (nonzero[i-1]*t)%10。
否则nonzero[i] = res[((nonzero[i-1]*t)%10)/2][five];
其中t是除掉所有因子5的结果，five为因子5数量对4的模。相关题目：
https://www.360docs.net/doc/054490175.html,的第1222题。不过这一道题注意的是，它的输入n并非只在32位int数值范围内，而是有很大的长度，所以计算这道变态题目时，需要利用到高精度除法(n/=5)和高精度加法(cnt+=n)。
(2). 阶乘末尾有多少个0
分析发现，实际上形成末尾0，就是因子5的数量，而计算1~n之间包含一个因子i的个数的简单算法就是：
cnt = 0; while (n) { n /= i; cnt += n; }
因此，直接将i换成5，就可以得到因子5的数量，也即n!末尾0的数量。相关题目：https://www.360docs.net/doc/054490175.html,的第2022题。
(3). 返回阶乘左边的第二个数字
简单算法：用实数乘，超过100就除以10，最后取个位即可。因为整数部分的个位就是阶乘结果左边的第二个数字。相关题目：
https://www.360docs.net/doc/054490175.html,的1016题。
(4). 判断数值 m 是否可以整除 n!
算法：使用素因子判断法
A. 首先直接输出两种特殊情况：
m == 0 则0肯定不会整除n!；
n >= m 则m肯定可以整除n!;
B. 那么就只剩最后一种情况：m > n，我们从m的最小素因子取起，设素因子为i那么可以求得m的素因子i的个数 nums1；再检查闭区间 i ~ n 之间的数，一共包含多少个素因子i，就可以简单的利用上面(2)中所介绍的数学公式进行计算得到nums2。如果nums2 < nums1，就表示1 ~ n中包含素因子的数量 < 除数m包含素因子i的数量，那么m必然不能整除n!，置ok = false。
C. 最后：如果 !ok or m > n or m == 0 则不能整除；否则可以整除
相关题目：https://www.360docs.net/doc/054490175.html,的第1850题。
(5).数字N能否表示成若干个不相同的阶乘的和：
这里可以选择的阶乘为：0! ~ 9!，实际上这一题与数论无关，与搜索有关。相关题目：https://www.360docs.net/doc/054490175.html, 的2358题。
分析，由于可供选择的阶乘数量较少，直接可以利用DFS搜索来做：
A. 首先将0 ~ 9的阶乘作一个表A[10]；再设置一个可以组成“和”的数组ans[N]。
B. 深度优先搜索方法：
search(n) {
for(i = n; i <= 9; i++) {
sum += A[i]; //求和
如果sum在ans数组中不存在，则将sum插入到ans[]数组中
search(n+1);
sum -= A[i]; //回溯
}
}
C. 最后对于输入n，就在ans数组中查找是否存在n，如果存在，则表示n可以表示成不同的阶乘和，否则不行。
阶乘的计算和处理程序设计
阶乘的计算及处理程序设计 一、问题描述 要求输入一个自然数n，求n！，同时统计结果中有几个0。 二、课题分析 1）计算n！。 2）统计0的个数。 三、数据结构的设计 x:输入的数n i:n! b:储存数据i上的各位上的数，从而判断b是否为0 j:统计0的个数 四、处理结构的设计 建立两个函数f1和f2，使f1函数起到求阶乘的作用，f2函数起到求0个数的作用。
求阶乘流程图
计算0的个数流程 五、源程序 1）主要结构体： f1函数： long int f1(int x) { long int i; //声明长整型变量i if (x==0||x==1) //采用递归函数f1求阶乘i=1; else i=f1(x-1)*x; return (i); }
f2函数： int f2(int i) {int j=0; int b=0; while(i>=10) //循环结构，判断末位是否为零，再去末位{b=i %10; if(b==0)j++; i=i/10; } return (j); } 2)整体： #include
N阶乘的递归调用展开式
long fact(int n) 1 { 2 long k; 3 if (n<0) 4 { 5 printf( “Data error!\n”); 6 exit(0); 7 } 8 else if (n==0||n==1) k=1; 9 else k=n*fact(n-1); 10 return k; 11 } main() { int n; long f; printf(“Please input an integral number:\n”); scanf(“%d”, &n); f=fact(n); printf(“%d!=%ld\n”, n, f); }
求fact(4)的详解过程, 执行了的语句用红色表示long fact(4) 1 { 2 long k; 3 if (4<0) 4 { 5 printf( “Data error!\n”); 6 exit(0); 7 } 8 else if (4==0||4==1) k=1; 9 else k=4*fact(4-1); /*断点1：调用fact(3)*/ 10 return k; 11 }
long fact(3) 1 { 2 long k; 3 if (3<0) 4 { 5 printf( “Data error!\n”); 6 exit(0); 7 } 8 else if (3==0||3==1) k=1; 9 else k=3*fact(3-1); /*断点2：调用fact(2)*/ 10 return k; 11 }
long fact(2) 1 { 2 long k; 3 if (2<0) 4 { 5 printf( “Data error!\n”); 6 exit(0); 7 } 8 else if (2==0||2==1) k=1; 9 else k=2*fact(2-1); /*断点3：调用fact(1)*/ 10 return k; 11 }
阶乘运算
//阶乘各算法的 C++ 类实现 #include
计算N的阶乘
北华航天工业学院 课程设计报告（论文） 设计课题：计算N的阶乘 专业班级： 学生姓名： 指导教师： 设计时间：2010年12月16日
北华航天工业学院电子工程系 微机原理与接口技术课程设计任务书 指导教师：刘金梅教研室主任： 2010年12 月18 日
内容摘要 本次课程设计编写计算N！的程序。数值N由键盘输入，结果在屏幕上输出，通过编制一个阶乘计算程序，了解怎样在汇编语言一级上实现高级语言中的数学函数。其难点在于随着N的增大，其结果远非寄存器所能容纳。这就必须把结果放在一个内存缓冲区中。然而乘法运算只限于两个字相乘，因此要确定好算法，依次从缓冲区中取数，进行两字相乘，并将DX中的高16位积作为产生的进位。 索引关键词：N的阶乘汇编语言内存缓冲区
目录 序言————————————————————5 正文————————————————————5 一、程序算法————————————————-—-5 二、源程序—————————————————-—-6 三、程序运行与调试—————————————-—11 四、N的阶乘程序流动图——————————-—-—11 心得体会——————————————————13 参考文献——————————————————13
序言 本文是关于微型计算机原理写文件课程设计。编写程序，将内存区域中用调试程序（DEBUG）设置好的一连串数据（以Ctrl+z为结束符）做为一个文件存入磁盘，文件名为DATA.ASM。内存区域的段地址和偏移地址在程序中输入。 随着计算机的高速发展，微型计算机已经应用到各个领域，微型计算机原理应用技术已经成为电子信息的核心产业。 微型计算机原理是计算机科学与技术、通讯工程、电气工程、机电工程的核心课程。 通过这次课程设计，是我们更好地理解了课程中所学的理论知识，并把实际问题转化为理论知识，学会如何把学到的知识用于解决实际问题，培养我们的动手能力。 正文 一、程序算法 阶乘的定义为N!=N(N-1)(N-2)……2,从左至右依次计算，结果保存在缓冲区BUF中。缓冲区BUF按结果由高到低依次排列。程序首先将BP初始化为N，N 不等于0或1则将N送入BUF缓冲区最低字节单元中。然后使BP为N-1，以后BP依次减1，直到变化为1为止。每次让BP与BUF中的字节单元按由低到高的次序相乘。低位结果AX仍保存在相应的BUF字节单元中，高位结果DX则送到进位字单元CY中，作为高字相乘时从低字来的进位，初始化CY为0.计算结果的长度随着乘积运算而不断增长。由字单元LEN指示。LEN单元初始化为1。当最高字单元与BP相乘时。若DX不为0，则结果长度要扩展。
20以内的阶乘和
1、程序实现目标：输入1~20的数字n，求n以内数据的阶乘之和。 1! + 2! + 3! +......+n! = ? void GetCount(int Num ,float pOutput[]) { } void main() { float pNumber[2] = {0}; Number = 20; GetCount(Number ,pNumber); } ========================================================= 20!可以存放在float中，注意unsigned long完全存放不下20！，更不要说阶乘和了。 float的范围是-3.4*10（负的38次方），3.4*10（正的38次方） ========================================================= #include
输入正整数n,计算n的阶乘c++实验报告
实验五 一、实验内容 1、掌握3种循环结构:while,do-while,for的区别与联系,以及他们之间相互转换的方法,并能正确使用他们. 2,掌握与循环语句相关的break语句和continue语句的使用方法. 二、实验目的 1、掌握3种循环结构:while,do-while,for的区别与联系,以及他们之间相互转换的方法,并能正确使用他们. 2,掌握与循环语句相关的break语句和continue语句的使用方法. 三、实验步骤 实践教程例题1 1.输入正整数n,计算n的阶乘. 2.实践教程例2 输入若干字符,统计其中数字字符.白字符和其它字符的个数,输入EOF结束. 3、实践教程例3 N个人围坐成一圈，从1开始顺序编号；游戏开始，从第一个人开始由1到m循环报数，报到m的人退出圈外，问最后留下的那个人原来的序号。 4`书2.3 设计程序将输入的百分制成绩转换为五分制输出，90分以上为5分，80~89为4分，70~79为3分，60~69为两分，60分以下为1分。 书2.5 编译打印如下图形 * * * * * * * * * * * * * * * * * * * * * * * * *
4、书2.7 输入n，求1！+2！+3！+…+n！。 四、实验数据及处理结果 实践教程例1 #include 汇编语言程序设计报告 课程设计题目：采用汇编语言实现阶乘运算 学号：10081437 姓名：张子琦 院系：测试与光电工程学院 专业：测控技术与仪器 指导教师：陈振华 采用汇编语言实现阶乘运算 学生姓名：张子琦班级：10081437 指导老师：陈振华 摘要：汇编语言是微型计算机原理及应用的基础，微机主机和接口所要实现的功能都要通过汇编语言来实现。尽管汇编语言程序设计编程效率低，但其运行效率高、速度快。因此掌握汇编语言是学好微机原理和接口设计的第一步。编写计算N！的程序。数值由键盘输入，结果在屏幕上输出。[1] 关键字:汇编语言N！键盘输入屏幕输出 指导老师签名： Factorial implemented in assembly language Student name :Ziqi Zhang Class:10081437 Supervisor:Zhenhua Chen Abstract:Assembly language is the basis of the principles and applications of the microcomputer, the microcomputer host functions and interfaces to achieve should be achieved through the assembly language. Despite the low efficiency of assembly language programming programming, but it’s high operating efficiency, and speed. Therefore, the assembly language is the first step to learn Microcomputer Principle and Interface Design. Written calculation of N! Procedures. Numerical keyboard input, output results on the screen. Key words:Assembly language N! Keyboard input Screen output Signature of Supervisor: 阶乘排列组合公式计算 加法原理：做一件事，完成它可以有N类加法，在第一类办法中有M1种不同的方法，在第二类办法中有M2种不同的方法，……，在第N类办法中有MN种不同的方法。那么完成这件事共有N=M1+M2+...+MN 种不同的方法。即一次性完成的用加法原理。 乘法原理：做一件事，完成它需要分成N个步骤，做第一步有M1种不同的方法，做第二步有M2种不同的方法，……，做第N步有MN种不同的方法，那么完成这件事共有 N=M1×M2×... ×MN 种不同的方法。即二次以上完成的用乘法原理。 排列：从N个不同元素中，任取M（M<=N）个元素，按照一定的顺序排成一列，叫做从N个不同元素中取出M个元素的一个排列。 排列数：从N个不同元素中取出M（M<=N）个元素的所有排列的个数，叫做从N个不同元素中取出M个元素的排列数。记作：Pmn 排列数公式：Pmn =n(n-1)(n-2)...(n-m+1) 全排列：N个不同元素全部取出的一个排列，叫做N个不同元素的一个全排列。 自然数1到N的连乘积，叫做N的阶乘。记作：n! 。0!=1。 全排列公式：Pnn =n! 排列数公式还可写成：Pmn = n!/(n-m)! 组合：从N个不同元素中，任取M（M<=N）个元素并成一组，叫做从N个不同元素中取出M个元素的一个组合。 排列与元素的顺序有关，组合与元素的顺序无关。 组合数：从N个不同元素中取出M（M<=N）个元素的所有组合的个数，叫做从N个不同元素中取出M个元素的组合数。记作：Cmn 组合数公式：Cmn = Pmn / Pmm = n(n-1)(n-2)...(n-m+1)/m! = n!/m!/(n-m)! 组合性质1：Cmn = Cn-mn ( C0n =1) 组合性质2：Cmn+1 = Cmn + Cm-1n 高精度算法的基本思想，就是将无法直接处理的大整数，分割成若干可以直接处理的小整数段，把对大整数的处理转化为对这些小整数段的处理 数据结构的选择 每个小整数段保留尽量多的位 使用Comp类型 采用二进制表示法 每个小整数段保留尽量多的位 一个例子：计算两个15位数的和 ?方法一 ?分为15个小整数段，每段都是1位数，需要15次1位数加法 ?方法二 ?分为5个小整数段，每段都是3位数，需要5次3位数加法 ?方法三 ?Comp类型可以直接处理15位的整数，故1次加法就可以了 ?比较 ?用Integer计算1位数的加法和3位数的加法是一样快的 ?故方法二比方法一效率高 ?虽然对Comp的操作要比Integer慢，但加法次数却大大减少 ?实践证明，方法三比方法二更快 使用Comp类型 高精度运算中，每个小整数段可以用Comp类型表示 Comp有效数位为19～20位 求两个高精度数的和，每个整数段可以保留17位 求高精度数与不超过m位整数的积，每个整数段可以保留18–m位 求两个高精度数的积，每个整数段可以保留9位 如果每个小整数段保留k位十进制数，实际上可以认为其只保存了1位10k进制数，简称为高进制数，称1位高进制数为单精度数 采用二进制表示法 采用二进制表示，运算过程中时空效率都会有所提高，但题目一般需要以十进制输出结果，所以还要一个很耗时的进制转换过程。因此这种方法竞赛中一般不采用，也不在本文讨论之列. 算法的优化 高精度乘法的复杂度分析 连乘的复杂度分析 设置缓存 分解质因数求阶乘 二分法求乘幂 分解质因数后的调整 高精度乘法的复杂度分析 计算n位高进制数与m位高进制数的积 ?需要n*m次乘法 ?积可能是n+m–1或n+m位高进制数 连乘的复杂度分析（1） 一个例子：计算5*6*7*8 ?方法一：顺序连乘 ?5*6=30，1*1=1次乘法 ?30*7=210，2*1=2次乘法 一、设计题目 编写计算N！的程序（数值N由键盘输入，结果在屏幕上输出。N的范围为0-65535，即刚好能被一个16位寄存器容纳）。 二、开发目的 由于当N值较大时（N>10），N的阶乘计算很繁琐并且计算容易出错。 所以可以编写计算N！的程序，利用计算机强大的计算能力计算N！。这不仅能节省繁琐计算的时间，而且得到的N！的积比起手工算的要准确。 三、设计方案 N的阶乘为1*2*3……(N-1)*N,N的范围为（0000H—FFFFH），N!以字为单位存在一个或几个定义的数据段中。 若已算到（n-1）！，假如它占4个字的空间，接下来它乘以n的原理，如图1所示。 图1 （n-1）！* n的原理 因此计算N！的算法可以这样编写，当前n！的值为被乘数，内容存在str2中，单位为字，n+1的值为乘数,存在str1中，单位也为字。被乘数从str2首地址中内容开始与乘数相乘，得到32位的积，它的低16位覆盖掉当前被乘数所在存储空间的内容。接着str2下一个字的内容与乘数相乘，也得到32位的积，前一个积的高16位与现在积的低16位相加，它们的和覆盖掉当前被乘数所在存储空间的内容，若它们的和有进位，把进位加到现在积的高16位。直到把str2中内容乘完。然后乘数增1，循环上面的内容。 直到执行完（N-1）！*N 输入的N为4位16进制数，输出也为16进制数。 四、程序流程图 五、程序清单 data1 segment input1 db 'please input the number :','$' input2 db 10,?,10 dup(?) ；输入的16进制数 error db 'Out of range','$' output1 db 'The answer is 1','$' output2 db 'The answer is :','$' str1 dw 100 dup(?) ；保存1—N（后一个数覆盖前一个数）str2 dw 7000h dup(?) ;N！乘积的值（1） p dw 100 dup(?) ;上一个乘积的高16位 data1 ends data2 segment str3 dw 7fffh dup(?) ；N！乘积的值（2） data2 ends code segment assume cs:code,ds:data1,es:data2 org 100h ；程序从偏移地址100h开始执行 start: mov ax,data1 ；程序初始化 mov ds,ax mov ax,data2 mov es,ax ；初始化结束 mov ah,9 lea dx,input1 int 21h 天文数的阶乘计算 在C语言里unsigned long int型的的整数的仅可表示0～4294967295之间的数，而12! = 479001600，13! = 6227020800。可见，用unsigned long int型的整数做阶乘运算时最多只能计算到12的阶乘。用函数double sqrt(double x)做开方算运算时，只能计算到16位有效数字。long double型的实数虽然可表示10-4931～10-4932的数，但其有效数字也只有18～19位。 我编写了一个"天文数字计算"程序突破了这一限制，可以把数字的长度扩充到无穷多位。除了能做加、减、乘、除、求模等基本运算外还可以做阶乘、乘方、开平方等运算。 例如：10000! = ?、(2002^2000)%9999 = 9394、2002的平方根的小数点后第10000位是4。 下面这个程序只是我用编写的"天文数字计算"里的一个计算。 因为在程序代码中使用了中文，所以这个程序如果不在中文DOS下运行，可能会出现乱码，但不影响程序的计算结果。 注：因为DOS能访问的内存有限，所以在DOS下可把计算结果扩充到30000多位。但如果用VC把它编绎成Windows程序，则可以计算到"真正的无穷多位"（与机子配置有关），一般计算到几十万位是没有问题的。 /* 此程序在TC2.0、TC3.0，BC，VC下都可编绎 */ #define M 20000 /* 结果位数，DOS能访问的内存有限，不要超过 30000 位*/ #define N (M+5) main() { int Num; reGISter int i,j,k,flag; register unsigned int n,m,pc; unsigned char str_n[5],result_0[N],result_1[N]; void fun_print_result(char *result,int flag); int fun_mul(char *a,char *b,char *c,int flag); 科技学院 课程设计报告 ( 2012—2013 年度第一学期) 课程：微机原理及应用 题目：计算N的阶乘 院系：动力工程系 班级： 学号： 学生姓名： 指导教师： 设计周数：一周 成绩： 日期：2013年1 月11 日 《微机原理及应用》课程设计 任务书 一、目的与要求 1．通过对微机系统分析和具体设计，使学生加深对所学课程的理解。 2．掌握汇编语言程序设计的基本方法和典型接口电路的基本设计方法。 3．培养学生分析问题、解决问题的能力。 4．培养学生对微型计算机应用系统的基本设计能力。 5．提高学生的实践动手能力和创新能力。 二、主要内容 设计题目：计算N的阶乘。数值N由键盘输入，N的范围为0~65535，结果在屏幕上显示。 1．针对所选择的设计题目进行硬件设计，合理选用所需元器件，绘制系统结构框图、硬件接线图，并在实验系统上完成电路的连接和调试。 2．根据所选题目的要求对微机系统进行程序设计，绘制程序总体流程图并编写源程序上机调试。 3．写出课程设计报告，对整个设计过程进行归纳和综合，对设计中所存在的问题和不足进行分析和总结，提出解决的方法、措施、建议和对这次设计实践的认识和收获。 三、进度计划 四、设计成果要求 1．系统硬件设计合理，软件编程达到设计要求。 2．系统硬件结构图和软件流程图绘制清楚规范。 3．设计报告完整规范。 五、考核方式 根据设计任务的完成情况、课程设计报告撰写情况及演示答辩情况采用五级记分制评定成绩。 学生姓名： 指导教师： 一、课程设计目的与要求 1．通过对微机系统分析和具体设计，使学生加深对所学课程的理解。 2．掌握汇编语言程序设计的基本方法和典型接口电路的基本设计方法。 3．培养学生分析问题、解决问题的能力。 4．培养学生对微型计算机应用系统的基本设计能力。 5．提高学生的实践动手能力和创新能力 二、课程设计正文 1.程序正文 CRLF MACRO MOV AH,02H MOV DL,0DH INT 21H MOV AH,02H MOV DL,0AH INT 21H ENDM ;回车换行 DATA SEGMENT MESS1 DB ‘INPUT THE NUMBER ACCORDING TO HEXNUM!’,0DH,0AH, ‘$’ MESS2 DB ‘THE RESULT IS:’,0DH,0AH, ‘$’ ERROR DB ‘INPUT ERROR!’,0DH,0AH, ‘$’ LEN DW 1 CYY DW ? BUF DW 256 DUP (0) DATA ENDS STACK SEGMENT STA DW 32 DUP (?) TOP DW ? STACK ENDS CODE SEGMENT ASSUME CS:CODE,DS:DATA,ES:DATA,SS:STACK START: MOV AX,DATA MOV DS,AX MOV ES,AX MOV SP,TOP HUNAN UNIVERSITY 程序设计训练报告 题目求n！ 学生姓名 学生学号 专业班级 学院名称 指导老师 2013 年 7 月 11 日 目录 第一部分程序功能简介 (3) 第二部分本人完成的主要工作 (3) 第三部分设计方案 (4) （一）设计分析 (4) （二）模块的功能及程序说明 (5) （三）核心源程序模块 (7) （四）核心算法流程图 (8) （五）操作方法简介 (9) （六）实验结果 (9) （七）设计体会 (10) 第四部分附录 ....................... 错误!未定义书签。 （一）程序中主要变量的功能说明........ 错误!未定义书签。 （二）源程序代码...................... 错误!未定义书签。 第一部分程序功能简介 该程序是求一个大数n的阶乘（n!），n的值范围从1~100之间变化。输出结果从右往左每四个数之间用一个“，”隔开。 第二部分本人完成的主要工作 刚开始，我尝试着通过递归函数（如下）将100！的结果算出 结果发现无法得到正确结果（100的阶乘输出为0），询问后知道由于100的阶乘结果太大，用长字符串也会溢出导致无法显示，所以只能将阶乘后结果的个、十、百、千...位依次赋数给数组a[200]来解决这一问题。 数组a[200]的引入也让n阶乘结果的位数昭然若揭，又使用for循环使输出结果从右往左每四个数之间用一个“，”隔开。 最终设计出一个程序求一个大正整数数的阶乘（n!），n的值范围从1~100之间变化（输出结果从右往左每四个数之间用一个“，”隔开）。然后对程序进行编译，运行，并不断完善细节，不断优化。 阶乘、排列、组合公式计算 ... 附：阶乘、排列、组合公式计算程序 加法原理：做一件事，完成它可以有N类加法，在第一类办法中有M1种不同的方法，在第二类办法中有M2种不同的方法，...，在第N类办法中有MN 种不同的方法。那么完成这件事共有 N=M1+M2+...+MN 种不同的方法。 乘法原理：做一件事，完成它需要分成N个步骤，做第一步有M1种不同的方法，做第二步有M2种不同的方法，...，做第N步有MN种不同的方法，那么完成这件事共有N=M1×M2×... ×MN 种不同的方 法。 排列：从N个不同元素中，任取M（M<=N）个元素，按照一定的顺序排成一列，叫做从N个不 同元素中取出M个元素的一个排列。 排列数：从N个不同元素中取出M（M<=N）个元素的所有排列的个数，叫做从N个不同元素中 取出M个元素的排列数。记作：Pmn 排列数公式：Pmn =n(n-1)(n-2)...(n-m+1) 全排列：N个不同元素全部取出的一个排列，叫做N个不同元素的一个全排列。 自然数1到N的连乘积，叫做N的阶乘。记作：n! （0!=1） 全排列公式：Pnn =n! 排列数公式还可写成：Pmn = n!/(n-m)! 组合：从N个不同元素中，任取M（M<=N）个元素并成一组，叫做从N个不同元素中取出M个 元素的一个组合。 排列与元素的顺序有关，组合与元素的顺序无关。 组合数：从N个不同元素中取出M（M<=N）个元素的所有组合的个数，叫做从N个不同元素中 取出M个元素的组合数。记作：Cmn 组合数公式：Cmn = Pmn / Pmm = n(n-1)(n-2)...(n-m+1)/m! = n!/m!/(n-m)! 排列组合公式/排列组合计算公式 排列A------和顺序有关 组合 C -------不牵涉到顺序的问题 排列分顺序,组合不分 例如把5本不同的书分给3个人,有几种分法. "排列" 把5本书分给3个人,有几种分法"组合" 1．排列及计算公式 从n个不同元素中，任取m(m≤n)个元素按照一定的顺序排成一列，叫做从n个不同元素中取出m个元素的一个排列；从n个不同元素中取出m(m≤n)个元素的所有排列的个数，叫做从n个不同元素中取出m个元素的排列数，用符号A(n,m)表示. A(n,m)=n(n-1)(n-2)……(n-m+1)= n!/(n-m)!(规定0!=1). 2．组合及计算公式 从n个不同元素中，任取m(m≤n)个元素并成一组，叫做从n 个不同元素中取出m个元素的一个组合；从n个不同元素中取出m(m≤n)个元素的所有组合的个数，叫做从n个不同元素中取出m个元素的组合数.用符号 c(n,m) 表示. c(n,m)=A(n,m)/m!=n!/((n-m)!*m!)；c(n,m)=c(n,n-m); 3．其他排列与组合公式 从n个元素中取出r个元素的循环排列数＝A(n,r)/r=n!/r(n-r)!. n个元素被分成k类，每类的个数分别是n1,n2,...nk这n个元素的全排列数为 n!/(n1!*n2!*...*nk!). k类元素,每类的个数无限,从中取出m个元素的组合数为 c(m+k-1,m). 排列（Anm(n为下标，m为上标)） Anm=n×（n-1）....（n-m+1）；Anm=n！/（n-m）！（注：！是阶乘符号）；Ann（两个n分别为上标和下标）=n！；0！=1；An1（n为下标1为上标）=n 阶乘(factorial)是基斯顿·卡曼(Christian Kramp, 1760 –1826)于1808年发明的运算符号。阶乘，也是数学里的一种术语。阶乘只有计算方法，没有简便公式的，只能硬算。 例如所要求的数是4，则阶乘式是1×2×3×4，得到的积是24，24就是4的阶乘。例如所要求的数是6，则阶乘式是1×2×3×……×6，得到的积是720，720就是6的阶乘。例如所要求的数是n，则阶乘式是1×2×3×……×n，设得到的积是x，x就是n的阶乘。 任何大于1的自然数n阶乘表示方法： n!=1×2×3×……×n 或 n!=n×(n-1)! n的双阶乘： 当n为奇数时表示不大于n的所有奇数的乘积 如：7!!=1×3×5×7 当n为偶数时表示不大于n的所有偶数的乘积(除0外) 如：8!!=2×4×6×8 小于0的整数-n的阶乘表示： (-n)!= 1 / (n+1)! 以下列出0至20的阶乘： 0!=1，注意(0的阶乘是存在的) 1!=1， 2!=2， 3!=6， 4!=24， 5!=120， 6!=720， 7!=5,040， 8!=40,320 9!=362,880 10!=3,628,800 11!=39,916,800 12!=479,001,600 13!=6,227,020,800 14!=87,178,291,200 15!=1,307,674,368,000 16!=20,922,789,888,000 17!=355,687,428,096,000 18!=6,402,373,705,728,000 19!=121,645,100,408,832,000 20!=2,432,902,008,176,640,000 另外，数学家定义，0!=1，所以0!=1! 一、实验目的 1. 掌握子程序的设计方法； 2. 掌握递归子程序的设计思想； 3. 体会堆栈操作在子程序嵌套中的重要作用。 二、实验原理及基本技术路线图（方框原理图） 一个子程序作为调用程序去调用另一子程序，这种关系称为子程序嵌套。由于子程序嵌套对堆栈的使用很频繁，因此还要确保堆栈有足够空间，并要注意堆栈的正确状态，这包括CALL、RET、RET N、PUSH、POP、INT、IRET等与堆栈操作有关指令的正确使用。 在子程序嵌套的情况下，如果一个子程序调用的子程序就是它自身，这样的子程序称为递归子程序。显然递归调用是子程序嵌套的一种特殊情况。使用递归算法往往能设计出效率较高的程序。 设计递归子程序时，必须保证每一次后继调用都不能破坏它上一次调用时所生成的参数和中间结果，并且该过程不会修改它本身。这就意味着当使用汇编语言设计递归子程序时，必须考虑每一次调用都应该把它的参数、寄存器和所有的中间结果保存到不同的存储区域。最好的办法是利用堆栈来存储这些信息，一次调用所保存的信息称为一帧。递归调用要使用大量的堆栈空间，一定要保证堆栈足够大，而且也要保证堆栈的正确使用，避免死机等不可预料的情况发生。 求N!算法流程图： 三、所用仪器、材料（设备名称、型号、规格等） 1. 操作系统平台：Windows Server 2003 2. 汇编环境：Microsoft MASM 5.0 3. 文本编辑器：记事本 四、实验方法、步骤 1. 将MASM5.0的文件置于C:\assembly\目录下； 2. 将masm.exe和link.exe所在目录（C:\assembly\MASM5）添加到Path环境变量中； 3.在C:\assembly\下新建一个JC.asm文件，打开JC.asm，输入汇编程序代码； 4. 运行一个命令行窗口，将当前目录切换到C:\assembly\，然后输入命令：masm JC.asm [Enter]，来汇编程序，根据汇编结果查看程序代码是否有语法错误，如有，则更正保存后重新汇编，直至没有错误为止，此时会生成JC.obj文件； 5. 输入命令：link JC.obj [Enter]，观察输出结果，如果没有错误，则生成JC.exe； 6. 输入命令：debug JC.exe [Enter]，调试程序，并记录运行过程； 7. 完成实验报告。 五、实验过程原始记录(数据、图表、计算等) 1. 将C:\assembly\MASM5目录添加到Path环境变量中： 2. 新建名为JC.asm的文件，输入汇编程序代码： *************************************(1)************************************ **************** 假如需要计算n+16的阶乘，n+16接近10000，已经求得n!（共有m个单元），（每个单元用一个long数表示，表示1-100000000） 第一种算法（传统算法） 计算(n+1)! 需要m次乘法，m次加法(加法速度较快,可以不予考虑,下同)，m次求余（求本位)，m次除法(求进位），结果为m+1的单元 计算(n+2)! 需要m+1次乘法，m+1次求余，m+1次除法, 结果为m+1个单元 计算(n+3)! 需要m+1次乘法，m+1次求余，m+1次除法，结果为m+2个单元 计算(n+4)! 需要m+2次乘法，m+2次求余，m+2次除法，结果为m+2个单元 计算(n+5)! 需要m+2次乘法，m+2次求余，m+2次除法，结果为m+3个单元 计算(n+6)! ... 计算(n+7)! ... 计算(n+8)! ... 计算(n+9)! ... 计算(n+10)! ... 计算(n+11)! ... 计算(n+12)! ... 计算(n+13)! ... 计算(n+14)! 需要m+7次乘法，m+7次求余，m+7次除法，结果为m+7个单元 计算(n+15)! 需要m+7次乘法，m+7次求余，m+7次除法，结果为m+8个单元 计算(n+16)! 需要m+8次乘法，m+8次求余，m+8次除法，结果为m+8个单元 该算法的复杂度：共需:m+(m+8)+(m+1+m+7)*7=16m+64次乘法，16m+64次求余，16m+64次除法 第二种算法： 1.将n+1 与n+2 相乘,将n+3 与n+4 相乘,将n+5 与n+6...n+15与n+16,得到8个数，仍然叫做n1,n2,n3,n4,n5,n6,n7,n8 2. n1 与n2相乘，结果叫做p2，结果为2个单元，需要1次乘法。 p2 与n3相乘，结果叫做p3，需要2次乘法，1次加法(加法速度快，下面省略），2次除法，2次求余 p3 与n4相乘，结果叫做p4，需要3次乘法，3次除法，3次求余 求某数的阶乘 /************while循环*******/ #include /**********for循环*********/ #include ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;宏定义 print_str macro x;宏定义输出字符串 lea dx,x mov ah,9 int 21h endm ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; DATAS SEGMENT ;此处输入数据段代码 n dw ?;存放该数 flag dw 0;判断是否输入为非数字 str1 db 'input the number:$' str2 db '!=$' str3 db 0ah,0dh,'again?(enter means stop,others means continue):$' str4 db '-------------------------------the max num is 8!--------------------------------',0ah,0dh,'$' error db 0ah,0dh,'not a num!$' enter1 db 0ah,0dh,'$' DATAS ENDS STACKS SEGMENT ;此处输入堆栈段代码 dw 20 dup(?) STACKS ENDS CODES SEGMENT ASSUME CS:CODES,DS:DATAS,SS:STACKS START: MOV AX,DATAS MOV DS,AX ;此处输入代码段代码 print_str str4 begin1: print_str str1 call input;将输入的数赋给n cmp flag,0 jne again1 mov dx,0 mov ax,n call output print_str str2 mov dx,0 mov ax,1 mov bx,n 北华航天工业学院课程设计报告（论文） 设计课题：计算N的阶乘 专业班级： 学生姓名： 指导教师： 设计时间： 2010年12月16日 北华航天工业学院电子工程系 微机原理与接口技术课程设计任务书 指导教师：刘金梅教研室主 任： 2010年 12 月 18 日 内容摘要 本次课程设计编写计算N！的程序。数值N由键盘输入，结果在屏幕上输出，通过编制一个阶乘计算程序，了解怎样在汇编语言一级上实现高级语言中的数学函数。其难点在于随着N的增大，其结果远非寄存器所能容纳。这就必须把结果放在一个内存缓冲区中。然而乘法运算只限于两个字相乘，因此要确定好算法，依次从缓冲区中取数，进行两字相乘，并将DX中的高 16位积作为产生的进位。 索引关键词： N的阶乘汇编语言内存缓冲区 目录 序言————————————————————5 正文————————————————————5 一、程序算法————————————————-—-5 二、源程序—————————————————-—-6 三、程序运行与调试—————————————-—11 四、N的阶乘程序流动图——————————-—-—11 心得体会——————————————————13 参考文献——————————————————13 序言 本文是关于微型计算机原理写文件课程设计。编写程序，将内存区域中用调试程序（DEBUG）设置好的一连串数据（以Ctrl+z为结束符）做为一个文件存入磁盘，文件名为DATA.ASM。内存区域的段地址和偏移地址在程序中输入。 随着计算机的高速发展，微型计算机已经应用到各个领域，微型计算机原理应用技术已经成为电子信息的核心产业。 微型计算机原理是计算机科学与技术、通讯工程、电气工程、机电工程的核心课程。 通过这次课程设计，是我们更好地理解了课程中所学的理论知识，并把实际问题转化为理论知识，学会如何把学到的知识用于解决实际问题，培养我们的动手能力。 正文 一、程序算法 阶乘的定义为N!=N(N-1)(N-2)……2,从左至右依次计算，结果保存在缓冲区BUF中。缓冲区BUF按结果由高到低依次排列。程序首先将BP初始化为N，N不等于0或1则将N送入BUF缓冲区最低字节单元中。然后使BP为N-1，以后BP依次减1，直到变化为1为止。每次让BP与BUF中的字节单元按由低到高的次序相乘。低位结果AX仍保存在相应的BUF字节单元中，高位结果DX则送到进位字单元采用汇编语言实现阶乘运算
阶乘排列组合公式计算
阶乘算法
用汇编语言计算N阶乘(0到FFFFH)
天文数的阶乘计算
微机原理课程设计报告计算N的阶乘
n的阶乘程序报告
阶乘
排列组合和排列组合计算公式
高中数学阶乘公式
汇编--N阶乘
大数阶乘算法
求某数的阶乘的4种方法
n的阶乘汇编语言
计算N的阶乘