변경 전 내용

/**
 * 이 클래스는 사용자가 지정한 최대 값까지 소수를 생성한다. 사용된 알고리즘은
 * 에라토스테네스의 체다.
 * <p>
 * 에라토스테네스: 기원전 276년에 리비아 키레네에서 출생 ...
 * 설명 ...
 * <p>
 * 알고리즘은 상당히 단순하다. 2에서 시작하는 정수 배열을 대상으로
 * 2의 배수를 모두 제거한다. 다음으로 남은 정수를 찾아 이 정수의 배수를 모두 지운다.
 * 최대 값의 제곱근이 될 때까지 이를 반복한다.
 * 
 * @author Alphonse
 * @version 13 Feb 2002 atp
 *
 */

public class GeneratePrimes {
    
    /**
     * @param maxValue는 소수를 찾아낼 최대 값
     * @return int[]
     */
    public static int[] generatePrimes(int maxValue) {
        if(maxValue >= 2) { // 유일하게 유효한 경우
            // 선언
            int s = maxValue + 1; // 배열 크기
            boolean[] f = new boolean[s];
            int i;
            
            // 배열을 참으로 초기화
            for(i=0; i<s; i++) {
                f[i] = true;
            }
            
            // 소수가 아닌 알려진 숫자를 제거
            f[0] = f[1] = false;
            
            // 체
            int j;
            for(i=2; i<Math.sqrt(s)+1; i++) {
                if(f[i]) {  // i가 남아있는 숫자라면 이 숫자의 배수를 구한다.
                    for(j=i*2; j<s; j+=i) {
                        f[j] = false;   // 배수는 소수가 아니다.
                    }
                }
            }
            
            // 소수 개수는?
            int count = 0;
            for(i=0; i<s; i++) {
                if(f[i]) {
                    count ++;   // 카운트 증가
                }
            }
            
            int[] primes = new int[count];
            
            // 소수를 결과 배열로 이동한다.
            for(i=0, j=0; i<s; i++) {
                if(f[i]) {  // 소수일 경우
                    primes[j++] = i;
                }
            }
            
            return primes;  // 소수 반환
        } else {    // maxValue < 2
            return new int[0];  // 입력이 잘못되어 비어 있는 배열을 반환한다.
        }
    }
}

변경 할 내용

쓸데 없는 역사 설명 주석은 제거한다.

단순하다? 불필요한 설명 제거한다

저자와 버전? Git 에서 관리가 가능하므로 제거 다만 CopyRight 가 필요할 경우는 최상단에 따로 추가한다

클래스이름이 마치 함수 같다 클래스 이름 변경

JavaDocs 같은 설명 제거한다 불필요하다 함수만 보면 딱 알 수 있다.

예외처리를 먼저 해주면 좋을것 같다.
 else {    // maxValue < 2
            return new int[0];  // 입력이 잘못되어 비어 있는 배열을 반환한다.
        }
이 부분을 최상단으로 옮겨 알고리즘의 예외경우를 먼저 제거한다.

변수 이름이 너무 단순하다 변수 이름을 정확하게 수정한다.

주석과 추가 줄바꿈으로 의미 문단이 나눠져있는 부분들을 모아 함수로 변경한다.

변경 한 내용

using System;
using System.Collections.Generic;
using System.Linq;

public class PrimeGenerator // 에라토스테네스의 체 알고리즘 사용
{
    private static List<bool> crossedOuts = new List<bool>();
    private static int minmumValue = 2;

    public static List<int> GeneratePrimes(int maxValue)
    {
        if (maxValue < minmumValue) {
            return null;
        }
        else {
            InitializeCrossedOuts(maxValue);
            CrossOutMultiples(maxValue);
            return GetPrimes();
        }
    }

    private static void InitializeCrossedOuts(int maxValue)
    {
        for (int i = 0; i < minmumValue; i++) {
            crossedOuts.Add(true);

        }

        for (int i = minmumValue; i < crossedOuts.Count(); i++) {
            crossedOuts.Add(false);
        }
    }

    private static void CrossOutMultiples(int maxValue)
    {
        int limit = GetCrossOutIterationLimit(maxValue);
        for (int i = minmumValue; i <= limit; i++) {
            if (IsNotCrossed(i)) {
                CrossOutMultiplesOf(i, maxValue);
            }
        }
    }

    private static int GetCrossOutIterationLimit(int maxValue)
    { // 배열에 있는 모든 수는 배열 크기의 제곱근보다 작은 소수의 인수이므로 제곱근보다 더 큰 숫자의 배수는 제거할 필요가 없다.
        double iterationLimit = Math.Sqrt(maxValue);
        return (int)iterationLimit;
    }

    private static bool IsNotCrossed(int index)
    {
        return crossedOuts[index] == false;
    }

    private static void CrossOutMultiplesOf(int value, int maxValue)
    {
        for (int multiple = value * 2; multiple < maxValue; multiple += value) {
            crossedOuts[multiple] = true;
        }
    }

    private static List<int> GetPrimes()
    {
        var result = new List<int>();
        for (var i = minmumValue; i < crossedOuts.Count(); i++) {
            if (IsNotCrossed(i)) {
                result.Add(i);
            }
        }

        return result;
    }
}

변경 전 내용

/**
 * 이 클래스는 사용자가 지정한 최대 값까지 소수를 생성한다. 사용된 알고리즘은
 * 에라토스테네스의 체다.
 * <p>
 * 에라토스테네스: 기원전 276년에 리비아 키레네에서 출생 ...
 * 설명 ...
 * <p>
 * 알고리즘은 상당히 단순하다. 2에서 시작하는 정수 배열을 대상으로
 * 2의 배수를 모두 제거한다. 다음으로 남은 정수를 찾아 이 정수의 배수를 모두 지운다.
 * 최대 값의 제곱근이 될 때까지 이를 반복한다.
 * 
 * @author Alphonse
 * @version 13 Feb 2002 atp
 *
 */

public class GeneratePrimes {
    
    /**
     * @param maxValue는 소수를 찾아낼 최대 값
     * @return int[]
     */
    public static int[] generatePrimes(int maxValue) {
        if(maxValue >= 2) { // 유일하게 유효한 경우
            // 선언
            int s = maxValue + 1; // 배열 크기
            boolean[] f = new boolean[s];
            int i;
            
            // 배열을 참으로 초기화
            for(i=0; i<s; i++) {
                f[i] = true;
            }
            
            // 소수가 아닌 알려진 숫자를 제거
            f[0] = f[1] = false;
            
            // 체
            int j;
            for(i=2; i<Math.sqrt(s)+1; i++) {
                if(f[i]) {  // i가 남아있는 숫자라면 이 숫자의 배수를 구한다.
                    for(j=i*2; j<s; j+=i) {
                        f[j] = false;   // 배수는 소수가 아니다.
                    }
                }
            }
            
            // 소수 개수는?
            int count = 0;
            for(i=0; i<s; i++) {
                if(f[i]) {
                    count ++;   // 카운트 증가
                }
            }
            
            int[] primes = new int[count];
            
            // 소수를 결과 배열로 이동한다.
            for(i=0, j=0; i<s; i++) {
                if(f[i]) {  // 소수일 경우
                    primes[j++] = i;
                }
            }
            
            return primes;  // 소수 반환
        } else {    // maxValue < 2
            return new int[0];  // 입력이 잘못되어 비어 있는 배열을 반환한다.
        }
    }
}