如何使用數組在java中使用其質數對數字進行編碼？

Question

我有這個問題我想解決

我寫了這段代碼

public static int[] encodeNumber(int n) {
    int count = 0, base = n, mul = 1;

    for (int i = 2; i < n; i++) {
        if(n % i == 0 && isPrime(i)) {
            mul *= i;
            count++;
            if(mul == n) {
                break;
            }
            n /= i;
        }
    }

    System.out.println("count is " + count);

    int[] x = new int[count];

    int j = 0;

    for (int i = 2; i < base; i++) {
        if(n % i == 0 && isPrime(i)) {
            mul *= i;
            x[j] = i;
            j++;
            if(mul == n)    break;
            n /= i;
        }
        break;
    }

    return x;
}

public static boolean isPrime(int n) {
    if(n < 2)   return false;
    for (int i = 2; i < n; i++) {
        if(n % i == 0)  return false;
    }
    return true;
}

我試圖在計數變量中獲取其質因子的數量，並使用該計數創建一個數組，然后在第二個循環中使用其質因子填充該數組。

count is 3
[2, 0, 0]

輸入為 6936。所需的輸出是一個包含其所有質因子{2, 2, 2, 3, 17, 17}的數組。

Answer 1

您的count是錯誤的，因為您只計算了6936 2和17等多個因素一次。

我建議以類似於以下方式遞歸地執行此操作：（此代碼未經測試）

void encodeNumberRecursive(int remainder, int factor, int currentIndex, Vector<Integer> results) {
     if(remainder<2) {
         return;
     }
     if(remainder % factor == 0) {
         results.push(factor);
         remainder /= factor; 
         currentIndex += 1; 
         encodeNumberRecursive(remainder , factor, currentIndex, results);  
     } else {
         do {
            factor += 1;
         } while(factor<remainder && !isPrime(factor));
         if(factor<=remainder) {
             encodeNumberRecursive(remainder , factor, currentIndex, results); 
         }
     }
}

最后，調用它

Vector<Integer> results = new Vector<Integer>();
encodeNumberRecursive(n, 2, 0, results);

你也可以不用遞歸來做，我只是覺得它更容易。

Answer 2

好吧，這是我要開始的一段代碼。 它還沒有完成，我沒有測試它，但基本上你應該這樣做。

// First find the number of prime factors

int factorsCount = 0;
    int originalN = n;
    while (n > 1) {
       int p = findLowestPrimeFactor(n);
       n /= p;
       factorsCount++;
    }

    // Now create the Array of the appropriate size 

    int[] factors = new int[factorsCount];

    // Finally do the iteration from the first step again, but now filling the array.
    n = originalN;
    int k = 0;
    while (n > 1) {
       int p = findLowestPrimeFactor(n);
       factors[k] = p;
       k++;
       n = n / p;
    }

    return factors;

Answer 3

找到一個因素（增加候選人），你可以假設它是素數，如果你把這個因素除掉，直到候選人不再是一個因素。

您的問題不是重復除以因子。

public static int[] encodeNumber(int n) {
    if (n <= 1) {
        return null;
    }

    List<Integer> factors = new ArrayList<>();
    for (int i = 2; n != 1; i += 1 + (i&1)) {
        while (n % i == 0) { // i is automatically prime, as lower primes done.
            factors.add(i);
            n /= i;
        }
    }
    return factors.stream().mapToInt(Integer::intValue).toArray();
}

沒有數據結構，花費兩倍的時間：

public static int[] encodeNumber(int n) {
    if (n <= 1) {
        return null;
    }
    // Count factors, not storing them:
    int factorCount = 0;
    int originalN = n;
    for (int i = 2; n != 1; i += 1 + (i&1)) {
        while (n % i == 0) {
            ++factorCount;
            n /= i;
        }
    }

    // Fill factors:
    n = originalN;
    int[] factors = new int[factorCount];
    factorCount = 0;
    for (int i = 2; n != 1; i += 1 + (i&1)) {
        while (n % i == 0) {
            factors[factorCount++] = i;
            n /= i;
        }
    }
    return factors;
}