头图

stackoverflow 提问:“计算两个整数的最小公倍数的最有效方法是什么?”

作者:小傅哥
博客:https://bugstack.cn
源码:https://github.com/fuzhengwei...

沉淀、分享、成长,让自己和他人都能有所收获!😄

一、前言

嘿,小傅哥怎么突然讲到最大公约数了?

这么想你肯定是没有好好阅读前面章节中小傅哥讲到的RSA算法,对于与欧拉结果计算的互为质数的公钥e,其实就需要使用到辗转相除法来计算出最大公约数。

放心,你所有写的代码,都是对数学逻辑的具体实现,无非是难易不同罢了。所以如果你真的想学好编程思维而不只是CRUD,那就要把数据结构、算法逻辑等根基打牢。

二、短除法

既然都说到这了,那你还记得怎么计算最大公约数吗,死鬼?

img

以上这种方式就是我们在上学阶段学习的,这种计算方式叫做短除法。

短除法:是算术中除法的算法,将除法转换成一连串的运算。短除法是由长除法简化而来,当中会用到心算,因此除数较小的除法比较适用短除法。对大部分的人而言,若除以12或12以下的数,可以用记忆中乘法表的内容,用心算来进行短除法。也有些人可以处理除数更大的短除法。—— 来自维基百科

三、欧几里德算法

短除法能解决计算最大公约数的问题,但放到程序编写中总是很别扭,总不能一个个数字去试算,这就显得很闹挺。其实除了短除法还有一种是计算公约数的办法,叫做欧几里德算法。

欧几里德算法:是计算两个整数(数字)的最大公约数【GCD(Greatest Common Divisor)】的有效方法,即能将它们整除而无余数的最大数。它以古希腊数学家 欧几里得的名字命名,欧几里德在他的几何原本(约公元前 300 年)中首次描述了它。它是算法的示例,是根据明确定义的规则执行计算的分步过程,并且是常用的最古老的算法之一。它可以用来减少分数到他们的最简单的形式,并且是许多其他数论和密码计算的一部分。—— 来自维基百科

GCD,代表了两个数字的最大公约数,GCD(X,Y) = Z,那么就表示 X 和 Y 的最大公约数是 Z。由欧几里德算法给出 GCD(X,Y) = GCD(Y,XmodY) —— mod 表示求模计算余数。

其实简单来说就是,X和Y的公约数是Z,那么Y和Z的公约数也是Z。24和18的最大公约数是6,那么18和6的公约数也是6。嘿,就这么一个事。但就因为有了这一样一条推论,让编程代码变得优雅舒服,只需要不断地将X、Y两数作差,就能计算最大公约数。

😂 这让小傅哥想起,多年前上学时候,我也给出过一条推论;”任意一组所能构成等差数列的三个数字,所能组合出来的一个三位数,都能被3整除。“ 例如:等差数列 163146 组合成三位数 463116 或者 461631 都能被3整除。

四、辗转相除法代码实现

欧几里德算法 = 辗转相除法法https://en.wikipedia.org/wiki...

在辗转相除法的实现中,计算最大公约数的方式,就是使用一个数字减去另外一个数字,直到两个数字相同或者有其中一个数字为0,那么最后不为零的那个数字就是两数的最大公约数。

小傅哥在这里提供了2种计算方式,一种是循环另外一种是递归。—— 方便很多看不懂递归的小伙伴可以用另外的方式学习。

1. 循环实现

public long gcd01(long m, long n) {
    m = Math.abs(m);
    n = Math.abs(n);
    
    while (m != 0 && n != 0 && m != n) {
        if (m > n) {
            m = m - n;
        } else {
            n = n - m;
        }
    }
    return m == 0 ? n : m;
}
  • 两数循环处理中,条件为 m != 0 && n != 0 && m != n 直至循环结束。

2. 递归实现

public long gcd02(long m, long n) {
    if (m < n) {
        long k = m;
        m = n;
        n = k;
    }
    if (m % n != 0) {
        long temp = m % n;
        return gcd02(n, temp);
    } else {
        return n;
    }
}
  • 计算方式逻辑和条件是一样的,只不过这个是使用了递归调用的方式进行处理。

3. 测试验证

@Test
public void test_euclidean() {
    Euclidean euclidean = new Euclidean();
    System.out.println(euclidean.gcd01(124, 20));
    System.out.println(euclidean.gcd02(124, 20));
}

测试结果

4
4


Process finished with exit code 0
  • 计算 124 和 20 的最大公约数,两个计算方式结果都是 4 。好的,到这测试通过。
  • 这并不是一个很难的知识点,但当你做一些技术分享、答辩述职等时候,能这样用技术语言而不是大白话的讲述出来后,其实高度就有了。兄弟!👬🏻

stackoverflow.com 看到一道问题:计算两个整数的最小公倍数的最有效方法是什么?

img

乍一看,🤨 这能有啥。不就是计算下最小公倍数吗?但一想我脑袋中计算最小公倍数的方法;一种是在本子上通过短除法计算,另外一种是基于计算出的最大公约数,再使用公式:lcm(a, b) = |a * b| / gcd(a, b) 求得最小公倍数。—— 计算最大公约数是基于欧几里德算法(辗转相除法)

那么这样的计算方法是不是最有效的方法,另外如果是同时计算多个整数的最小公倍数,要怎么处理?

其实编程的学习往往就是这样,留心处处都是学问,你总是需要从各种细小的点中,积累自己的技术思维广度和纵向探索深度。好啦,接下来小傅哥就给大家介绍几种用于计算最小公倍数的算法。

五、用公约数实现

公式:lcm(a, b) = |a * b| / gcd(a, b)

public long lcm01(long m, long n) {
    return ((m == 0) || (n == 0)) ? 0 : Math.abs(m * n) / gcd(m, n);
}

private long gcd(long m, long n) {
    m = Math.abs(m);
    n = Math.abs(n);
    // 从一个数字中减去另一个数字,直到两个数字变得相同。
    // 这将是 GCD。如果其中一个数字为零,也退出循环。
    // https://en.wikipedia.org/wiki/Euclidean_algorithm
    while (m != 0 && n != 0 && m != n) {
        if (m > n) {
            m = m - n;
        } else {
            n = n - m;
        }
    }
    return m == 0 ? n : m;
}
  • 首先这里是一个比较简单的方式,基于两数乘积除以最大公约数,得到的结果就是最小公倍数。

六、简单累加计算

此计算方式为,在一组正整数数列中,通过找到最小的数字进行自身累加循环,直至所有数字相同时,则这个数字为最小公倍数。—— 你能代码实现一下吗?

img

public long lcm02(long... n) {
    long[] cache = n.clone();
    // 以所有数字都相等作为条件
    while (!isEquals(n)) {
        System.out.println(JSON.toJSONString(n));
        long min = n[0];
        int idx = 0;
        for (int i = 0; i < n.length; i++) {
            if (min > n[i]) {
                min = n[i];
                idx = i;
            }
        }
        n[idx] = cache[idx] + min;
    }
    return n[0];
}
  • 在代码实现中,首先要把n个整数数列进行克隆保存。因为每次相加的都是最初的这个数列里的数字值。接下来就是以所有数字都相等作为条件循环判断,不断地的累加最小的数值即可。最终返回的就是最小公倍数。

七、表格推演计算

表格计算方式为将一组数字以最小的质数2开始整除,直到不能被2整除后,用下一个质数3继续整除(剩余的数字中比大的最小的质数)直至所有数字都为1的时候结束。最终所有有效的质数乘积就是最小公倍数。—— 想想如果这让你用代码实现,你能肝出来吗?

img

public long lcm03(long... n) {
    Map<Long, List<Long>> keys = new HashMap<>();
    for (long key : n) {
        keys.put(key, new ArrayList<Long>() {{
            add(key);
        }});
    }
    System.out.print("执行表格计算:\r\nx ");
    long primality = 2, cachePrimality = primality, filterCount = 0, lcm = 1;
    // 以所有元素最后一位为1作为条件
    while (filterCount != keys.size()) {
        int refresh = 0;
        filterCount = 0;
        for (Map.Entry<Long, List<Long>> entry : keys.entrySet()) {
            long value = entry.getValue().get(entry.getValue().size() - 1);
            if (value == 1) {
                filterCount++;
            }
            // 整除处理
            if (value % primality == 0) {
                entry.getValue().add(value / primality);
                refresh++;
            } else {
                entry.getValue().add(value);
            }
        }
        // 刷新除数
        if (refresh == 0) {
            for (Map.Entry<Long, List<Long>> entry : keys.entrySet()) {
                long value = entry.getValue().get(entry.getValue().size() - 1);
                // 找到下一个符合的素数
                if (value > primality || (value < cachePrimality && value > primality)) {
                    cachePrimality = value;
                }
                entry.getValue().remove(entry.getValue().size() - 1);
            }
            primality = cachePrimality;
        } else {
            // 累计乘积
            lcm *= cachePrimality;
            System.out.print(cachePrimality + " ");
        }
    }
    keys.forEach((key, values) -> {
        System.out.println();
        for (long v : values) {
            System.out.print(v + " ");
        }
    });
    System.out.println("\r\n");
    return lcm;
}
  • 在代码实现中我们通过 Map 作为表的key,Map 中的 List 作为表每一行数据。通过这样一个结构构建出一张表。
  • 接下来以所有元素最后一位为1作为条件循环处理数据,用最开始的2作为素数整除列表中的数据,并保存到下一组数列中。当2不能整除时,则刷新素数,选取另外一个列表中最小的素数作为除数继续。
  • 这个过程中会累计有效素数的乘积,这个乘积的最终结果就是最小公倍数。

八、测试验证

单元测试

@Test
public void test_euclidean() {
    LastCommonMultiple lastCommonMultiple = new LastCommonMultiple();
    // System.out.println("最小公倍数:" + lastCommonMultiple.lcm01(2, 7));
    System.out.println("最小公倍数:" + lastCommonMultiple.lcm02(3, 4, 6));
    // System.out.println("最小公倍数:" + lastCommonMultiple.lcm03(3, 4, 6));
     System.out.println("最小公倍数:" + lastCommonMultiple.lcm03(3, 4, 6, 8));
   //System.out.println("最小公倍数:" + lastCommonMultiple.lcm03(4, 7, 12, 21, 42));
}

测试结果

执行累加计算:
[3,4,6]
[6,4,6]
[6,8,6]
[9,8,6]
[9,8,12]
[9,12,12]
最小公倍数:12

执行表格计算:
x 2 2 2 3 
3 3 3 3 1 
4 2 1 1 1 
6 3 3 3 1 
8 4 2 1 1 

最小公倍数:24
  • 到这里测试就结束了,本章一共介绍了三种计算最小公倍数的方法。那如果只让你看到逻辑,你能写出最终的代码吗?

九、常见面试

  • 最大公约数的使用用途?
  • 如何使用代码实现最大公约数计算?
  • 你是否了解欧几里德算法?
  • 关于数论你还记得多少?
  • RSA 加密算法为什么需要用到公约数计算?
  • 如何计算两数的最小公倍数?
  • 如果计算多个整数的最小公倍数?
  • 你能说一下具体如何实现这种X的计算流程吗?
  • 你知道最小公倍数计算的用途吗?


CodeGuide_程序员编码指南
公众号:bugstack虫洞栈,回复:设计模式,可以下载《重学Java设计模式》PDF,全网下载量17万+ | 这是一...

CodeGuide | 程序员编码指南 - 原创文章、案例源码、资料书籍、简历模版等下载。

4.6k 声望
28.4k 粉丝
0 条评论
推荐阅读
我来告诉你,ChatGPT 该怎么对接到自己的项目中!
《ChatGPT AI 问答助手》 开源免费项目,涵盖爬虫接口、ChatGPT API对接、DDD架构设计、镜像打包、Docker容器部署,小巧精悍,流程全面。对于Java编程伙伴来说,非常具有学习价值。

小傅哥

封面图
从零搭建 Node.js 企业级 Web 服务器(十五):总结与展望
总结截止到本章 “从零搭建 Node.js 企业级 Web 服务器” 主题共计 16 章内容就更新完毕了,回顾第零章曾写道:搭建一个 Node.js 企业级 Web 服务器并非难事,只是必须做好几个关键事项这几件必须做好的关键事项就...

乌柏木60阅读 6k评论 16

从零搭建 Node.js 企业级 Web 服务器(一):接口与分层
分层规范从本章起,正式进入企业级 Web 服务器核心内容。通常,一块完整的业务逻辑是由视图层、控制层、服务层、模型层共同定义与实现的,如下图:从上至下,抽象层次逐渐加深。从下至上,业务细节逐渐清晰。视图...

乌柏木39阅读 7.1k评论 6

从零搭建 Node.js 企业级 Web 服务器(二):校验
校验就是对输入条件的约束,避免无效的输入引起异常。Web 系统的用户输入主要为编辑与提交各类表单,一方面校验要做在编辑表单字段与提交的时候,另一方面接收表单的接口也要做足校验行为,通过前后端共同控制输...

乌柏木32阅读 6.1k评论 9

从零搭建 Node.js 企业级 Web 服务器(五):数据库访问
回顾 从零搭建 Node.js 企业级 Web 服务器(一):接口与分层,一块完整的业务逻辑是由视图层、控制层、服务层、模型层共同定义与实现的,控制层与服务层实现了业务处理过程,模型层定义了业务实体并以 对象-关系...

乌柏木32阅读 4.5k评论 9

从零搭建 Node.js 企业级 Web 服务器(十三):断点调试与性能分析
Node.js 官方提供了断点调试机制,出于安全性考虑默认为关闭状态,可以通过 node 参数 --inspect 或 --inspect-brk 开启,配合 IDE 能够非常方便地调试代码,本章就上一章已完成的项目 licg9999/nodejs-server-ex...

乌柏木29阅读 3.8k评论 9

从零搭建 Node.js 企业级 Web 服务器(八):网络安全
计算机网络依据 TCP/IP 协议栈分为了物理层、网络层、传输层、应用层,通常基础设施供应商会解决好前三层的网络安全问题,需要开发者自行解决应用层的网络安全问题,本章将着重表述应用层常见的网络安全问题及处...

乌柏木31阅读 5.7k评论 1

CodeGuide | 程序员编码指南 - 原创文章、案例源码、资料书籍、简历模版等下载。

4.6k 声望
28.4k 粉丝
宣传栏