Java: lấy ước số chung lớn nhất

Tôi đã thấy rằng một chức năng như vậy tồn tại cho BigInteger, tức là BigInteger#gcd. Có những chức năng khác trong Java mà cũng làm việc với nhiều loại khác ( int, longhay Integer)? Có vẻ như điều này sẽ có ý nghĩa như java.lang.Math.gcd(với tất cả các loại quá tải) nhưng nó không có ở đó. Nó ở một nơi nào khác?

(Đừng nhầm lẫn câu hỏi này với "làm cách nào để tôi tự thực hiện điều này", làm ơn!)

Đối với int và long, như là nguyên thủy, không thực sự. Đối với Integer, có thể ai đó đã viết một.

Cho rằng BigInteger là một tập siêu số (toán học / chức năng) của int, Integer, long và Long, nếu bạn cần sử dụng các loại này, hãy chuyển đổi chúng thành BigInteger, thực hiện GCD và chuyển đổi kết quả trở lại.

private static int gcdThing(int a, int b) {
    BigInteger b1 = BigInteger.valueOf(a);
    BigInteger b2 = BigInteger.valueOf(b);
    BigInteger gcd = b1.gcd(b2);
    return gcd.intValue();
}

Theo như tôi biết, không có bất kỳ phương pháp tích hợp nào cho các nguyên thủy. Nhưng một cái gì đó đơn giản như thế này sẽ thực hiện được mẹo:

public int gcd(int a, int b) {
   if (b==0) return a;
   return gcd(b,a%b);
}

Bạn cũng có thể viết một dòng nếu bạn quan tâm đến vấn đề đó:

public int gcd(int a, int b) { return b==0 ? a : gcd(b, a%b); }

Cần lưu ý rằng hoàn toàn không có sự khác biệt giữa cả hai khi chúng biên dịch sang cùng một mã byte.

Hoặc thuật toán Euclid để tính GCD ...

public int egcd(int a, int b) {
    if (a == 0)
        return b;

    while (b != 0) {
        if (a > b)
            a = a - b;
        else
            b = b - a;
    }

    return a;
}

Sử dụng Ổi LongMath.gcd()vàIntMath.gcd()

Trừ khi tôi có Ổi, tôi định nghĩa như thế này:

int gcd(int a, int b) {
  return a == 0 ? b : gcd(b % a, a);
}

Jakarta Commons Math có chính xác điều đó.

ArithmeticUtils.gcd (int p, int q)

Bạn có thể sử dụng việc triển khai thuật toán Binary GCD này

public class BinaryGCD {

public static int gcd(int p, int q) {
    if (q == 0) return p;
    if (p == 0) return q;

    // p and q even
    if ((p & 1) == 0 && (q & 1) == 0) return gcd(p >> 1, q >> 1) << 1;

    // p is even, q is odd
    else if ((p & 1) == 0) return gcd(p >> 1, q);

    // p is odd, q is even
    else if ((q & 1) == 0) return gcd(p, q >> 1);

    // p and q odd, p >= q
    else if (p >= q) return gcd((p-q) >> 1, q);

    // p and q odd, p < q
    else return gcd(p, (q-p) >> 1);
}

public static void main(String[] args) {
    int p = Integer.parseInt(args[0]);
    int q = Integer.parseInt(args[1]);
    System.out.println("gcd(" + p + ", " + q + ") = " + gcd(p, q));
}

}

Từ http://introcs.cs.princeton.edu/java/23recursion/BinaryGCD.java.html

Một số triển khai ở đây không hoạt động chính xác nếu cả hai số đều âm. gcd (-12, -18) là 6, không phải -6.

Vì vậy, một giá trị tuyệt đối sẽ được trả về, giống như

public static int gcd(int a, int b) {
    if (b == 0) {
        return Math.abs(a);
    }
    return gcd(b, a % b);
}

chúng ta có thể sử dụng hàm đệ quy để tìm gcd

public class Test
{
 static int gcd(int a, int b)
    {
        // Everything divides 0 
        if (a == 0 || b == 0)
           return 0;

        // base case
        if (a == b)
            return a;

        // a is greater
        if (a > b)
            return gcd(a-b, b);
        return gcd(a, b-a);
    }

    // Driver method
    public static void main(String[] args) 
    {
        int a = 98, b = 56;
        System.out.println("GCD of " + a +" and " + b + " is " + gcd(a, b));
    }
}

Nếu bạn đang sử dụng Java 1.5 trở lên thì đây là một thuật toán GCD nhị phân lặp đi lặp lại, sử dụng Integer.numberOfTrailingZeros()để giảm số lần kiểm tra và lặp lại cần thiết.

public class Utils {
    public static final int gcd( int a, int b ){
        // Deal with the degenerate case where values are Integer.MIN_VALUE
        // since -Integer.MIN_VALUE = Integer.MAX_VALUE+1
        if ( a == Integer.MIN_VALUE )
        {
            if ( b == Integer.MIN_VALUE )
                throw new IllegalArgumentException( "gcd() is greater than Integer.MAX_VALUE" );
            return 1 << Integer.numberOfTrailingZeros( Math.abs(b) );
        }
        if ( b == Integer.MIN_VALUE )
            return 1 << Integer.numberOfTrailingZeros( Math.abs(a) );

        a = Math.abs(a);
        b = Math.abs(b);
        if ( a == 0 ) return b;
        if ( b == 0 ) return a;
        int factorsOfTwoInA = Integer.numberOfTrailingZeros(a),
            factorsOfTwoInB = Integer.numberOfTrailingZeros(b),
            commonFactorsOfTwo = Math.min(factorsOfTwoInA,factorsOfTwoInB);
        a >>= factorsOfTwoInA;
        b >>= factorsOfTwoInB;
        while(a != b){
            if ( a > b ) {
                a = (a - b);
                a >>= Integer.numberOfTrailingZeros( a );
            } else {
                b = (b - a);
                b >>= Integer.numberOfTrailingZeros( b );
            }
        }
        return a << commonFactorsOfTwo;
    }
}

Bài kiểm tra đơn vị:

import java.math.BigInteger;
import org.junit.Test;
import static org.junit.Assert.*;

public class UtilsTest {
    @Test
    public void gcdUpToOneThousand(){
        for ( int x = -1000; x <= 1000; ++x )
            for ( int y = -1000; y <= 1000; ++y )
            {
                int gcd = Utils.gcd(x, y);
                int expected = BigInteger.valueOf(x).gcd(BigInteger.valueOf(y)).intValue();
                assertEquals( expected, gcd );
            }
    }

    @Test
    public void gcdMinValue(){
        for ( int x = 0; x < Integer.SIZE-1; x++ ){
            int gcd = Utils.gcd(Integer.MIN_VALUE,1<<x);
            int expected = BigInteger.valueOf(Integer.MIN_VALUE).gcd(BigInteger.valueOf(1<<x)).intValue();
            assertEquals( expected, gcd );
        }
    }
}

public int gcd(int num1, int num2) { 
    int max = Math.abs(num1);
    int min = Math.abs(num2);

    while (max > 0) {
        if (max < min) {
            int x = max;
            max = min;
            min = x;
        }
        max %= min;
    }

    return min;
}

Phương pháp này sử dụng thuật toán Euclid để lấy "Số chia chung lớn nhất" của hai số nguyên. Nó nhận hai số nguyên và trả về gcd của chúng. chỉ đơn giản vậy thôi!

Nó ở một nơi nào khác?

Apache!- nó có cả gcd và lcm, quá tuyệt!

Tuy nhiên, do độ sâu của việc triển khai, nó chậm hơn so với phiên bản viết tay đơn giản (nếu nó quan trọng).

/*
import scanner and instantiate scanner class;
declare your method with two parameters
declare a third variable;
set condition;
swap the parameter values if condition is met;
set second conditon based on result of first condition;
divide and assign remainder to the third variable;
swap the result;
in the main method, allow for user input;
Call the method;

*/
public class gcf {
    public static void main (String[]args){//start of main method
        Scanner input = new Scanner (System.in);//allow for user input
        System.out.println("Please enter the first integer: ");//prompt
        int a = input.nextInt();//initial user input
        System.out.println("Please enter a second interger: ");//prompt
        int b = input.nextInt();//second user input


       Divide(a,b);//call method
    }
   public static void Divide(int a, int b) {//start of your method

    int temp;
    // making a greater than b
    if (b > a) {
         temp = a;
         a = b;
         b = temp;
    }

    while (b !=0) {
        // gcd of b and a%b
        temp = a%b;
        // always make a greater than b
        a =b;
        b =temp;

    }
    System.out.println(a);//print to console
  }
}

Tôi đã sử dụng phương pháp này mà tôi đã tạo ra khi tôi 14 tuổi.

    public static int gcd (int a, int b) {
        int s = 1;
        int ia = Math.abs(a);//<-- turns to absolute value
        int ib = Math.abs(b);
        if (a == b) {
            s = a;
        }else {
            while (ib != ia) {
                if (ib > ia) {
                    s = ib - ia;
                    ib = s;
                }else { 
                    s = ia - ib;
                    ia = s;
                }
            }
        }
        return s;
    }

Các hàm GCD do Commons-Math và Guava cung cấp có một số khác biệt.

• Commons-Math ném ArithematicException.classchỉ cho Integer.MIN_VALUEhoặc Long.MIN_VALUE.
  • Nếu không, xử lý giá trị dưới dạng giá trị tuyệt đối.
• Guava ném một IllegalArgumentException.classgiá trị âm cho bất kỳ giá trị âm nào.

% Sẽ cung cấp cho chúng ta gcd Giữa hai số, nó có nghĩa là: -% hoặc mod của big_number / small_number are = gcd, và chúng ta viết nó trên java như thế này big_number % small_number.

EX1: cho hai số nguyên

  public static int gcd(int x1,int x2)
    {
        if(x1>x2)
        {
           if(x2!=0)
           {
               if(x1%x2==0)     
                   return x2;
                   return x1%x2;
                   }
           return x1;
           }
          else if(x1!=0)
          {
              if(x2%x1==0)
                  return x1;
                  return x2%x1;
                  }
        return x2;
        } 

EX2: cho ba số nguyên

public static int gcd(int x1,int x2,int x3)
{

    int m,t;
    if(x1>x2)
        t=x1;
    t=x2;
    if(t>x3)
        m=t;
    m=x3;
    for(int i=m;i>=1;i--)
    {
        if(x1%i==0 && x2%i==0 && x3%i==0)
        {
            return i;
        }
    }
    return 1;
}