Prime factorization with return being a string

Question

I am trying to solve the following coding challenge:

Given a positive number n > 1 find the prime factor decomposition of n. The result will be a string with the following form:

"(p1xxn1)(p2xxn2)...(pkxxnk)"

with the p(i) in increasing order and n(i) empty if n(i) is 1.

Example: n = 86240 should return "(2xx5)(5)(7xx2)(11)"

I believe I have figured out how to find the prime factors of a number... my problem is that I have no idea how to convert them into the form required by the question (i.e., a string where p(i) is in increasing order). I tried to convert an integer array containing the prime factors into some sort of array of tuples containing factors p and n, but I have been struggling fruitlessly for several hours.

Here is what I have so far:

func factors(_ number: Int) -> String {
    var changedNumber = number
    var numberArr = [Int]()

    while changedNumber >= 2 {
        for i in 2...changedNumber {
            if changedNumber % i == 0 {
                numberArr.append(i)
                changedNumber /= i
                break
            }
        }
    }
}

Any insight or resources would be greatly appreciated.

Answer 1

func factors(_ number: Int) -> String

I think it’s a mistake to make this return the String directly. It violates the separation of responsibilities, and makes this hard to reuse.

Imagine elsewhere in a codebase that uses this function, there might be a function which tries to parse the string result of this back into an array to use it in some other way. It may sound ridiculous, but a large number of the questions we get on here are about people trying to build systems to accept silly input from other systems that they should just change instead!

Here's what I would suggest:

func primeFactorization(of value: Int) -> (factor: Int, exponent: Int) {
    ...
}

func format(_ primeFactors: [(factor: Int, exponent: Int)]) -> String {
    return primeFactors
        .map { $0.exponent == 1 ? "(\($0.factor))" : "(\($0.factor)xx\($0.exponent))" }
        .joined()

}

So you can then do:

let factorization = primeFactorization(of: 86240)
// Which results in: [
//     (factor: 2, exponent: 5),
//     (factor: 2, exponent: 1),
//     (factor: 7, exponent: 2),
//     (factor: 11, exponent: 1),
// ]

// Which you can then format as this one question wants:
format(factorization) // => "(2xx5)(5)(7xx2)(11)"

For extra points, you could generify the first function into an extension on BinaryInteger, which would let you be able to write something like 86240.primeFactorization().