Encontrar el mínimo común múltiplo y el máximo común divisor de dos números

Esta tarde la primera lección de aritmética para quedarse pequeño trabajo, hacerlo sin problemas.
El máximo común divisor y el mínimo común múltiplo del concepto no se explica, Ley contra la violencia no dice indeseable.
Dicho aquí euclidiana y disminuciones método .

euclidiana

algoritmo de Euclides, es un método para la búsqueda el máximo común divisor de dos números naturales, algoritmo de Euclides también conocido.
Suponiendo m> = n, la fórmula: gcd (m, n) = mcd (n, m mod n)
medios que el máximo común divisor de n y m = n y m / n de un resto, hasta m mod n = 0, entonces n es el máximo común divisor y el mínimo común múltiplo = (m n) / GCD (m, n)
Nota: en el código escrito generalmente como m / gcd (m, n) * n, m impedido n excesivamente grande ráfaga de datos pueden explotar el alcance de
la código Java

	public static int gcd(int m, int n) {
        return m % n == 0 ? n : gcd(n, m % n);
    }

    public static void main(String[] args) {

       //最大公约数     5
        System.out.println(gcd(25, 15));
        //最小公倍数     75
        System.out.println(25 / gcd(25, 15) * 15);
    }

la ley disminuye

Fórmula: gcd (m, n) = gcd (n, mn), hasta Mn = 0, entonces m o n es el divisor más pequeño
de entrada dos enteros m y n (m> = n):

1) Si Mn = 0, entonces m (o n) es el máximo común divisor de dos números

2) Si mn ≠ 0, entonces m = n, n = mn y luego volver al paso 1

	public static int gcd2(int m, int n) {
        return m - n == 0 ? n : gcd2(n, m - n);
    }

    public static void main(String[] args) {
    
        //最大公约数     5
        System.out.println(gcd2(25, 15));
        //最小公倍数     75
        System.out.println(25 / gcd2(25, 15) * 15);
    }

enteros consecutivos algoritmo de detección

La estrategia general es comenzar con la adición de inicio más pequeño, si se agotan a cambio, no se dividirá en -1 ciclo.

	public static int gcd3(int m, int n) {

        int gcd = 1;
        if (m == n) {
            return n;
        } else {
            int min = m > n ? n : m;
            for (int i = min; i > 1; i--) {
                if (n % i == 0 && m % i == 0) {
                    return i;
                }

            }
            return gcd;
        }
    }

	public static void main(String[] args) {
     
        //连续整数检测
        //最大公约数     5
        System.out.println(gcd3(25, 15));
        //最小公倍数     75
        System.out.println(25 / gcd3(25, 15) * 15);
    }

factor de calidad de descomposición luego encontrar toda cuadratura común divisor

m, n cada una descomposición factorial, y luego comparar los dos grupos para encontrar toda el factor común es el máximo común divisor de cuadratura

	 public static int gcd4(int m, int n) {
        if (m == n) {
            return n;
        } else {
            //m的因数
            List<Integer> _first = new ArrayList<>();
            //n的因数
            List<Integer> _second = new ArrayList<>();

            //m分解质因数
            for (int i = 2; i <= m; i++) {

                while (m % i == 0 && m != 0) {
                    m /= i;
                    _first.add(i);
                }
                if (m == i) {
                    _first.add(i);
                    break;
                }

            }

            //n分解质因数
            for (int i = 2; i <= n; i++) {

                while (n % i == 0 && n != 0) {
                    n /= i;
                    _second.add(i);
                }
                if (n == i) {
                    _second.add(i);
                    break;
                }

            }
            //克隆m的所有因数
            Set<Integer> tmp = new HashSet<>(_first);
            //在m因数中除去m因数与n因数中共有部分 即公因数
            tmp.removeAll(_second);
            //克隆m所有因数
            Set<Integer> exist = new HashSet<>(_first);
            //除去剩余的tmp，剩余exist即为所有公因数list
            exist.removeAll(tmp);

            int gcd = 1;
            for (Integer i :exist) {
                gcd*=i;
            }

            return gcd;
        }
    }

	public static void main(String[] args) {
        //公因数算法检测
        //最大公约数     5
        System.out.println(gcd4(25, 15));
        //最小公倍数     75
        System.out.println(25 / gcd4(25, 15) * 15);

    }