Java 구소수와 최대 공약수의 간단한 코드 예

Java 예: 소수점 찾기
소수(질수)는 분해될 수 없는 수를 가리키며, 1과 그 자체를 제외하고는 다른 수를 정할 수 없다.이것은 작은 예로 어떻게 10만 이내의 모든 소수를 구하는지 설명한다.
 
소수의 분포는 규칙적으로 말할 수 없기 때문에 한 수가 소수인지 아닌지를 검사하려면 반드시 그것을 그것보다 작은 모든 수와 나누어야 한다.그러나 간단한 방법은 그것보다 작은 수를 검사할 필요가 없고, 그것보다 작은 소수를 검사하기만 하면 된다는 것이다.만약 그것보다 작은 모든 소수가 그것을 정돈할 수 없다면, 그것은 소수이다.

public class Primes { 
  
  public static void main(String[] args) { 
    //   
    List<Integer> primes = getPrimes(100000); 
  
    //   
    for (int i = 0; i < primes.size(); i++) { 
      Integer prime = primes.get(i); 
      System.out.printf("%8d", prime); 
      if (i % 10 == 9) { 
        System.out.println(); 
      } 
    } 
  } 
  
  /** 
   *   n   
   * 
   * @param n   
   * 
   * @return n   
   */ 
  private static List<Integer> getPrimes(int n) { 
    List<Integer> result = new ArrayList<Integer>(); 
    result.add(2); 
 
    for (int i = 3; i <= n; i += 2) { 
      if (!divisible(i, result)) { 
        result.add(i); 
      } 
    } 
  
    return result; 
  } 
  
  /** 
   *   n   
   * 
   * @param n     
   * @param primes   
   * 
   * @return   n   primes  ，  true。 
   */ 
  private static boolean divisible(int n, List<Integer> primes) { 
    for (Integer prime : primes) { 
      if (n % prime == 0) { 
        return true; 
      } 
    } 
    return false; 
  } 
} 

Java 예: 아날로그 분수의 클래스 Fraction
이것은 아날로그 분수 연산의 예: Fraction 클래스입니다.분수 연산이 끝난 후에는 최대 공약수로 분자 분모를 제거해야 한다.그래서 여기도 전유상제법으로 최대 공약수를 구하는 예가 있다.또한 Fraction 객체를 구성할 때 분모가 0이면 이상이 발생합니다. 이것도 필요한 검사입니다.

public class FractionTest { 
  
  public static void main(String[] args) { 
    Fraction a = new Fraction(7, 32); 
    Fraction b = new Fraction(13, 32); 
    System.out.println(a + " + " + b + " = " + a.add(b) + "(" + a.add(b).doubleValue() + ")"); 
    System.out.println(a + " - " + b + " = " + a.minus(b) + "(" + a.minus(b).doubleValue() + ")"); 
    System.out.println(a + " * " + b + " = " + a.multiply(b) + "(" + a.multiply(b).doubleValue() + ")"); 
    System.out.println(a + " / " + b + " = " + a.devide(b) + "(" + a.devide(b).doubleValue() + ")"); 
  } 
} 
  
//   
class Fraction { 
  private int numerator;   //   
  
  private int denominator;  //   
  
  Fraction(int numerator, int denominator) { 
    if (denominator == 0) { 
      throw new IllegalArgumentException("  0"); 
    } 
  
    this.numerator = numerator; 
    this.denominator = denominator; 
    shrink(); 
  } 
  
  Fraction() { 
    this(0, 1); 
  } 
  
  public int getNumerator() { 
    return numerator; 
  } 
  
  public void setNumerator(int numerator) { 
    this.numerator = numerator; 
  } 
  
  public int getDenominator() { 
    return denominator; 
  } 
  
  public void setDenominator(int denominator) { 
    this.denominator = denominator; 
  } 
  
  //   
  private Fraction shrink() { 
    int maxCommonDivisor = getMaxCommonDivisor(this.denominator, this.numerator); 
    this.numerator /= maxCommonDivisor; 
    this.denominator /= maxCommonDivisor; 
    return this; 
  } 
  
  //   
  private int getMaxCommonDivisor(int a, int b) { 
    int mod = a % b; 
  
    if (mod == 0) { 
      return b; 
    } else { 
      return getMaxCommonDivisor(b, mod); 
    } 
  } 
  
  //   
  public Fraction add(Fraction that) { 
    return new Fraction(this.numerator * that.denominator + this.denominator * that.numerator, 
        this.denominator * that.denominator); 
  } 
  
  //   
  public Fraction minus(Fraction that) { 
    return new Fraction(this.numerator * that.denominator - this.denominator * that.numerator, 
        this.denominator * that.denominator); 
  } 
  
  //   
  public Fraction multiply(Fraction that) { 
    return new Fraction(this.numerator * that.numerator, 
        this.denominator * that.denominator); 
  } 
  
  //   
  public Fraction devide(Fraction that) { 
    return new Fraction(this.numerator * that.denominator, 
        this.denominator * that.numerator); 
  } 
  
  public double doubleValue() { 
    return (double) numerator / denominator; 
  } 
  
  @Override 
  public String toString() { 
    return String.format("{%d/%d}", this.numerator, this.denominator); 
  } 
} 

 
출력 실행:

{7/32} + {13/32} = {5/8}(0.625)
{7/32} - {13/32} = {-3/16}(-0.1875)
{7/32} * {13/32} = {91/1024}(0.0888671875)
{7/32} / {13/32} = {7/13}(0.5384615384615384)