精华内容
下载资源
问答
  • 质因数分解 问题描述 求出区间[a,b]中所有整数的质因数分解。 输入格式 输入两个整数a,b。 输出格式 每行输出一个数的分解,形如k=a1a2a3…(a1<=a2<=a3…,k也是从小到大的)(具体可看样例) 样例输入 3 10 ...
  • NOIP2012年普及组复赛试题第1题《质因数分解》测试数据10组
  • 1620 质因数分解.cpp

    2020-05-15 20:15:20
    1620:质因数分解 时间限制: 1000 ms 内存限制: 524288 KB 提交数: 1390 通过数: 904 【题目描述】 原题来自:NOIP 2012 普及组 已知正整数 n 是两个不同的质数的乘积,试求出较大的那个质数。 【输入】 输入只有...
  • 主要介绍了Java实现的质因数分解操作,结合实例形式较为详细的分析了Java基于递归算法实现针对整数的质因数分解相关操作技巧,需要的朋友可以参考下
  • 质因数分解

    千次阅读 2017-10-13 20:27:19
    每个合数都可以写成几个质数相乘的形式,这几个质数就都叫做这个合数的质因数。如果一个质数是某个数的因数,那么就说这个质数是...正整数的因数分解可将正整数表示为一连串的质因子相乘,质因子如重复可以指数表示。根

    每个合数都可以写成几个质数相乘的形式,这几个质数就都叫做这个合数的质因数如果一个质数是某个数的因数,那么就说这个质数是这个数的质因数。而这个因数一定是一个质数。

    定义

    质因数(或质因子)在数论里是指能整除给定正整数质数两个没有共同质因子的正整数称为互质。因为1没有质因子,1与任何正整数(包括1本身)都是互质正整数的因数分解可将正整数表示为一连串的质因子相乘,质因子如重复可以指数表示。根据算术基本定理任何正整数皆有独一无二的质因子分解式。只有一个质因子的正整数为质数。
            例子
    • 1没有质因子。
    • 5只有1个质因子,5本身。(5是质数。)
    • 6的质因子是2和3。(6 = 2 × 3)
    • 2、4、8、16等只有1个质因子:2(2是质数,4 = 2,8 = 2,如此类推。)
    • 10有2个质因子:2和5。(10 = 2 × 5)
    就是一个数的约数,并且是质数,比如8=2×2×2,2就是8的质因数。12=2×2×3,2和3就是12的质因数。把一个式子以12=2×2×3的形式表示,叫做分解质因数。16=2×2×2×2,2就是16的质因数,把一个合数写成几个质数相乘的形式表示,这也是分解质因数[1]
    分解质因数的方法是先用一个合数的最小质因数去除这个合数,得出的数若是一个质数,就写成这个合数相乘形式;若是一个合数就继续按原来的方法,直至最后是一个质数 。
    分解质因数的有两种表示方法,除了大家最常用知道的“短除分解法”之外,还有一种方法就是“塔形分解法”。
    分解质因数对解决一些自然数乘积的问题有很大的帮助,同时又为求最大公约数最小公倍数做了重要的铺垫。

    计算方法

    短除法
    求一个数分解质因数,要从最小的质数除起,一直除到结果为质数为止。分解质因数的算式的叫短除法,和除法的性质差不多,还可以用来求多个个数的公因式
    最大公因数的一种方法,也可用来求最小公倍数
    求几个数最大公因数的方法,开始时用观察比较的方法,即:先把每个数的因数找出来,然后再找出公因数,最后在公因数中找出最大公因数。
    例如:求12与18的最大公因数。
    12的因数有:1、2、3、4、6、12。
    18的因数有:1、2、3、6、9、18。
    12与18的公因数有:1、2、3、6。
    12与18的最大公因数是6。
    这种方法对求两个以上数的最大公因数,特别是数目较大的数,显然是不方便的。于是又采用了给每个数分别分解质因数的方法。
    12=2×2×3
    18=2×3×3
    12与18都可以分成几种形式不同的乘积,但分成质因数连乘积就只有以上一种,而且不能再分解了。所分出的质因数无疑都能整除原数,因此这些质因数也都是原数的约数。从分解的结果看,12与18都有公约数2和3,而它们的乘积2×3=6,就是 12与18的最大公约数。
    采用分解质因数的方法,也是采用短除的形式,只不过是分别短除,然后再找公约数和最大公约数。如果把这两个数合在一起短除,则更容易找出公约数和最大公约数。
    从短除中不难看出,12与18都有公约数2和3,它们的乘积2×3=6就是12与18的最大公约数。与前边分别分解质因数相比较,可以发现:不仅结果相同,而且短除法竖式左边就是这两个数的公共质因数,而两个数的最大公约数,就是这两个数的公共质因数的连乘积。
    实际应用中,是把需要计算的两个或多个数放置在一起,进行短除。
    在计算多个数的最小公倍数时,对其中任意两个数存在的约数都要算出,其它无此约数的数则原样落下。最后把所有约数和最终剩下无法约分的数连乘即得到最小公倍数。
    只含有1个质因数的数一定是亏数
    (短除法详解:
    短除符号就是除号倒过来。短除就是在除法中写除数的地方写两个数共有的质因数,然后落下两个数被公有质因数整除的商,之后再除,以此类推,直到结果互质为止(两个数互质)。
    而在用短除计算多个数时,对其中任意两个数存在的因数都要算出,其它没有这个因数的数则原样落下。直到剩下每两个都是互质关系。
    求最大公因数乘一边,求最小公倍数乘一圈。
    公约数:亦称“公因数”。是几个整数同时均能整除的整数。如果一个整数同时是几个整数的约数,称这个整数为它们的“公约数”;公约数中最大的称为最大公约数。)
    在用短除计算多个数时,对其中任意两个数存在的因数都要算出,其它没有这个因数的数则原样落下。直到剩下每两个都是互质关系。求最大公约数遍乘左边所有数公共的因数,求最小公倍数遍乘一圈。这种方法对求两个以上数的最大公因数,特别是数目较大的数,显然是不方便的。于是又采用了给每个数分别分解质因数的方法
    Pollard Rho因数分解
    1975年,John M. Pollard提出了第二种因数分解的方法,Pollard Rho快速因数分解。该算法时间复杂度为O(n^(1/4))。
    分解质因数代码:
    将一个正整数分解质因数。例如:输入90,打印出90=2*3*3*5。
    程序分析:对n进行分解质因数,应先找到一个最小的质数k,然后按下述步骤完成: 
    (1)如果这个质数恰等于n,则说明分解质因数的过程已经结束,打印出即可。
    (2)如果n<>k,但n能被k整除,则应打印出k的值,并用n除以k的商,作为新的正整数你n,
     重复执行第一步。
    (3)如果n不能被k整除,则用k+1作为k的值,重复执行第一步。
    #include "stdio.h"
    #include "conio.h"
    main()
    {
      int n,i;
      printf("\nplease input a number:\n");
      scanf("%d",&n);
      printf("%d=",n);
      for(i=2;i<=n;i++)
        while(n!=i)
        {
          if(n%i==0)
          {
            printf("%d*",i);
            n=n/i;
          }
          else
            break;
        }
      printf("%d",n);
      getch();
    }
    另一种形式:
    //返回质因数数组 
    Integer[] decPrime(int n) { 
        List<Integer> list = new ArrayList<Integer>(); 
        for (int i=2;i <= n;i++){ 
            while(n != i){ 
                if(n%i != 0){ 
                    break;//不能整除肯定不是因数,能够整除在这里一定是质数。因为所有的2,3,5,7 
                          //都被除完之后。剩下的因数只能是奇数,且是质数。 
                } 
                list.add(Integer.valueOf(i)); 
                n = n/i; 
            } 
        } 
        list.add(Integer.valueOf(n)); 
        return list.toArray(new Integer[list.size()]); 
    }

    另外代码:

    。我们用所有正整数试验一下,从2开始进行试除,逐步增加除数的值,去寻找一个可以整除n的数。在Eratosthenes筛法的讨论中,我们知道如果n是一个复合数,那么它就会有一个素数 。算法9.3所示的就是这种方法的伪代码。这个算法有两个偱环路径,外部的和内部的。外部循环求唯一因数,内部循环求一个因数的多个复本。例如, ,外部循环求出因数2和3。内部循环求出2是一个多因数。

     

    01void trial_divisio_fac(int n)
    02{
    03    inta=2;
    04    while(a*a<=n)
    05    {
    06        while(n%a==0)
    07        {
    08            cout<<a<<ends;
    09            n=n/a;
    10        }
    11        a++;
    12    }
    13    if(n>1) cout<<n;//n没有因数
    14}

    上面的代码解释比较清楚。为什么这种方法可以得到素数。

    因为我们在内层循环中,已经把当前a的所有倍数都去除了。这跟埃斯托尼算法是一样的

    复杂度 如果 ,这种情况下试除法通常都是很有效的。但是如果用来分解更大的整数,试除法就变得非常低效甚至不可用了。这种算法的复杂度是随着n的增加呈指数级别增长的。

    试除法整数分解算法中最简单和最容易理解的算法。

    给定一个合数n(这里,n是待分解的整数),试除法看成是用小于等于\sqrt{n}的每个素数去试除待分解的整数。如果找到一个数能够整除除尽,这个数就是待分解整数的因子。

    ).

    例9.29

    运用试除算法求1233的因数。

    1233=3^2*137.

    转自:http://www.cnblogs.com/youxin/p/3232049.html



    展开全文
  • Primen 是一个教育软件,它通过分布式计算(使用 MPI.NET)和并行计算(使用 System.Threading.Tasks)实现素数分解(使用试除法)。 例如 Primen 可以分解两个素数的乘积,以便从公钥中获得 RSA 私钥。 如何使用它...
  • 于是写了一个质因数分解算法,可以实现输入一个数,给出质因数的分解形式 效果如下: 下面是源代码,仅供参考,欢迎批评指正或有更高效的算法,欢迎评论交流 import math def is_prime(x): if x==2: return True...

    在学习数论时学到任何一个数都可以分解成素数相乘的形式,
    于是写了一个质因数分解算法,可以实现输入一个数,给出质因数的分解形式
    效果如下:
    在这里插入图片描述

    下面是源代码,仅供参考,欢迎批评指正或有更高效的算法,欢迎评论交流

    import math
    
    def is_prime(x):
        if x==2:
            return True
        for i in range(2,int(math.sqrt(x))+1):
            if x%i==0:
               return False
        else:
            return True
    
    def factorization(x):#分解质因式
        list_factor=[]#存储质因数
        while not is_prime(x):
            for i in range(2,int(math.sqrt(x))+1):
                if (x%i==0 and is_prime(i)):
                    list_factor.append(i)
                    x//=i
                    break
        list_factor.append(x)
        return list_factor
    
    def print_factor(num,list_factor):#打印分解形式
        print('%d='%num,end='')
        for p in list_factor[:-1]:
            print(f'{p}*',end='')
        print(list_factor[-1])
    
    
    num=int(input('请输入一个整数:'))
    print_factor(num,factorization(num))
    
    展开全文
  • 分解质因数程序

    2017-10-06 17:05:27
    分解质因数C++的程序算法设计,较为高效的实现办法
  • 本文实例讲述了Python实现正整数分解质因数操作。分享给大家供大家参考,具体如下: 遇到一个Python编程练习题目:将一个正整数分解质因数。例如:输入90,打印出90=2*3*3*5。 #!/usr/bin/env python # -*- coding: ...
  • 质因数分解函数

    2020-01-01 15:10:43
    编写函数void func(unsinged int n),实现计算并输出一个正整数的质因数分解式。例如:n为90时,输出90=2*3*3*5。 ①是素数就输出: 可能直接想着先要做个判断了,如果是素数判断结束,输出这个素数。如果不是,...

    编写函数void func(unsinged int n),实现计算并输出一个正整数的质因数分解式。例如:n为90时,输出90=2*3*3*5。

    ①是素数就输出:

    可能直接想着先要做个判断了,如果是素数判断结束,输出这个素数。如果不是,在进入下面的分解的步骤吧。

    但是,有没有人想过素数的定义是什么?素数是一类只能被1或自身整除的数字对吧?如果去掉之前的这个判断,直接在接下来的分解步骤中去判断会怎样?

    假如输入了“11”,“11”是个素数,只能被1和11整除。那么,设置除数从2开始,是不是从2到10为止都没法整除呢?等到了11,11除以11刚好是1,这时候输出11。是不是和上面的判断的结果一样呢?

    ②、输出质因数的分解式,除数是素数:

    在这里可能会有人会疑惑了,如果只用素数整除,是不是应该写个函数去输出素数呢?从2开始,3、5、7、11这样的去循环输出着素数。假如除不尽2就换3,以此类推。

    如果真的这样去想,源码不仅会写的特别繁杂不说,还要经过反反复复的调试。那么,有没有更简单的方法呢?

    假如,输入一个数字24。24可以分解成3X8或者4X6对吧?但是我们按照①的想法走,第一个除数是2,那么3X8就直接出局了。可能有人会想,24除2得到12,2加1是3,12除以3是4,3再加1是4,除数中有非素数了,不对啊!!!!!!况且4还能拆分成两个2啊?!

    那么,可以在除以2的时候做个判断啊,如果第一次除后的所得的商能继续被2所整除,那除数就先不要加1就好了嘛!直到除不尽了,换下一个,以此类推。

    如果到4了呢?岂不是要出现非素数吗?

    不可能的,依照上面的想法,除数在没法整除后依次累加,得到的所有的除数只可能是素数。因为4在到达它之前,已经拆分成两个2了。如果是18,第一次得9,也就不会出现9,因为在9的前面已经有了3X3搞定了!!!

    因此,这道题无非就是考一个累除法的编写。

     

    #include <stdio.h>
    #include <string.h>
    
    void func(unsigned int n)
    {
    	int i=2,flag=0;
    	while(n>=2) {
    		if(n%i==0) {
    			if(flag==1)
    				printf("*");
    			printf("%d",i);
    			n=n/i;
    			flag=1;
    		} else {
    			i++;
    		}
    	}
    	printf("\n");
    }
    
    int main()
    {
    	int n;
    	while(scanf("%d",&n)!=EOF)
    		func(n);
    	return 0;
    }

     思路参考:https://blog.csdn.net/Issac_X10A/article/details/81773427

    展开全文
  • N!的质因数分解

    2013-12-01 16:53:30
    分解质因数幂的乘积。 【输入形式】 从标准输入读取一个整数N(1)。 【输出形式】 将结果写到标准输出。 输出结果格式为:p1^k1*p2^k2*…*pn^kn,其中: 1. N! = p1^k1*p2^k2*…*pn^kn; 2. pi为质数,(1 )...
  • #include <bits/stdc++.h> using namespace std;...//存储分解质因数 int prime[maxn],p_num=0;//存储质数 int num;//准备分解的数 int number = 0;//不同质因数的个数 bool is_prime(int n) { if
    #include <bits/stdc++.h>
    using namespace std;
    const int maxn = 1e5+10;
    struct Factor{
        int x,cnt;
    };
    Factor factor;
    Factor fac[10];//存储分解的质因数
    int prime[maxn],p_num=0;//存储质数
    int num;//准备分解的数
    int number = 0;//不同质因数的个数
    
    bool is_prime(int n)
    {
        if(n==1) return false;
        int sqr = (int)sqrt(n*1.0);
        for(int i=2;i<=sqr;i++)
            if(n%i==0) return false;
        return true;
    }
    void get_prime()
    {
        for(int i=2;i<maxn;i++)
            if(is_prime(i))
                prime[p_num++]=i;
    }
    void get_num()
    {
        cin>>num;
    }
    void disassemble(int n)
    {
        int sqr = (int)sqrt(n*1.0);
        for(int i=0;i<p_num&&prime[i]<=sqr;i++)
        {
            if(n%prime[i]==0)
            {
                fac[number].x = prime[i];
                fac[number].cnt = 0;
                while(n%prime[i]==0)
                {
                    fac[number].cnt++;
                    n/=prime[i];
                }
                number++;
            }
            if(n==1) break;
        }
        if(n!=1)
            fac[number].x = n,fac[number].cnt = 1;
    }
    void print()
    {
        cout<<num<<"="<<fac[0].x;
        for(int j=2;j<=fac[0].cnt;j++)
            cout<<"x"<<fac[0].x;
        for(int i=1;i<number;i++)
            for(int j=1;j<=fac[i].cnt;j++)
                cout<<"x"<<fac[i].x;
    }
    int main()
    {
        get_prime();
        get_num();
        disassemble(num);
        print();
        return 0;
    }
    
    
    

    注意:
    分解根据的原理是:
    对于一个正整数n来说,如果存在[2,n]范围内的质因子,那么这些质因子全部小于sqrt(n),或者最多只存在一个大于sqrt(n)的质因数。显然不可能会有两个这样的数否则想乘会大于n。

    展开全文
  • 质因数分解代码

    2021-07-18 16:26:27
    质因数分解 const int maxn = 5000005; // n:待分解质因数 // tot:不同质因数的值 // a[i]表示第i个质因数的值 // b[i]表示第i个质因数的指数 int a[maxn], b[maxn]; int factor(int n){ int temp, now; ...
  • 1089 质因数分解

    2021-08-16 18:57:27
    任意一个正整数可以分解成唯一的质因数的乘积,给出正整数,请计算出它的质因数分解式。 输入 每行一个正整数2<=n<=10^8。 输出 每行输出一个对应结果。使用”^”表示幂,”*”表示乘,质因子应该按从小到大的...
  • 质因数分解 首先将素数打表存下来。 然后对于每一个小于nnn的素数判断在n!n!n!中出现了几次。 然后就是如何进行第二步: 我们知道n!n!n!中每个小于n的质数一定会出现在n!n!n!中,所以这是一个连续的质数分解,...
  • python程序分解质因数

    2018-05-01 22:09:55
    质因数(素因数或质因子)在数论里是指能整除给定正整数的质数,这里通过运行python程序分解质因数
  • C语言--质因数分解(非常简洁的代码实现)

    千次阅读 多人点赞 2021-01-22 18:01:33
    C语言–质因数分解(非常简洁的代码实现) 这是百度上的概念:分解质因数只针对合数。(分解质因数也称分解素因数)求一个数分解质因数,要从最小的质数除起,一直除到结果为质数为止。分解质因数的算式叫短除法,和...
  • 题意: 给一个很大的数c,问是否存在a和b,使得a + b = c且rad(abc) <...注:rad(abc)等于abc相乘结果的质因数的乘积 思路: 要满足a + b = c,首先c可以表示成c = A * B * C * D…打表可以看出
  • 质因数分解 描述 已知正整数n是两个不同的质数的乘积,试求出较大的那个质数。 输入 每组输入数据只有一行,包含一个正整数n。 数据规模: 对于60%的数据,6≤n≤1000。 对于100%的数据,6≤n≤2*109。 输出 每组...
  • 质因数分解(包含重复的质因子) 如:12 = 223 8 = 222 1既不是质数也不是合数 以下四种求解质因数的方法,都用统一的接口: //分解的质因数,从小到大,存储在数组 primeFactors 中 static void getPrimeFactors...
  • ACM.质因数分解

    2020-02-15 00:27:28
    唯一分解定理 任意一个大于0的正整数都能被表示成若干个素数的乘积且表示方法是唯一的; 整理可以将相同素数的合并;可以得到 公式————n = P1^a1 * P2^a2 * …………* (P1 < P2 < ……Pn); ...
  • 递归实现质因数分解

    2020-06-24 11:31:12
    package java_practise; import java.util.Scanner; public class Hello { public static void Calcu(int val) { double tmp = val; int i; for(i=2; i<= Math.floor(Math.sqrt... //找到因数i Calcu
  •  求出区间[a,b]中所有整数的质因数分解。 输入格式  输入两个整数a,b。 输出格式  每行输出一个数的分解,形如k=a1a2a3…(a1<=a2<=a3…,k也是从小到大的)(具体可看样例) 样例输入 3 10 样例输出 3=3 4=22...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 24,018
精华内容 9,607
关键字:

质因数分解