The Challenge: Finding Common Denominators

You are presented with a list of fractions formatted as [ [numer_1, denom_1], ... [numer_n, denom_n] ], where all values are positive integers. Your goal is to output the fractions in the form:

(N_1, D) ... (N_n, D)

Here, D represents the smallest possible common denominator, ensuring that N_1/D equals numer_1/denom_1, and so forth for the other fractions.

For example, invoking the function convertFracs([(1, 2), (1, 3), (1, 4)]) should return "(6,12)(4,12)(3,12)".

Finding the Solution

The mathematical nature of this problem leads us to break it down into smaller, manageable components. The first step involves identifying the denominators from the array of fractions, which can be accomplished with specific functions:

const getNumerators = (lst) => lst.map((x) => x[0]);

const getDenominators = (lst) => lst.map((x) => x[1]);

To find a common denominator for all the fractions, we need to calculate the least common multiple (LCM) of the denominators. This requires a function to determine the greatest common divisor (GCD) of two numbers:

const gcd = (x, y) => (y === 0 ? x : gcd(y, x % y));

const lcm = (...n) => n.reduce((x, y) => (x * y) / gcd(x, y));

For further insights into GCD and LCM calculations, you can check out these resources:

• How to Find the Greatest Common Divisor in JavaScript
• An Overview of Different Methods to Calculate GCD in JavaScript
• How to Calculate the Least Common Multiple in JavaScript

Calculating New Numerators

Once we have identified the least common multiple, the next step is to compute the numerators for the fractions. This is done by multiplying the common denominator by the ratio of each fraction's numerator to its denominator:

const setNumerators = (den, lst) =>

lst.map((x) => [Math.round((x[0] / x[1]) * den), den]);

Finally, we can create a function to convert the individual fractions into a string format:

const stringify = (lst) => lst.map((x) => (${x[0]},${x[1]}));

The complete code for this process is as follows:

const gcd = (x, y) => (y === 0 ? x : gcd(y, x % y));

const lcm = (...n) => n.reduce((x, y) => (x * y) / gcd(x, y));

const getDenominators = (lst) => lst.map((x) => x[1]);

const setNumerators = (den, lst) =>

lst.map((x) => [Math.round((x[0] / x[1]) * den), den]);

const stringify = (lst) => lst.map((x) => (${x[0]},${x[1]}));

function convertFrac(lst) {

if (lst.length === 0) return "";

const d = getDenominators(lst);

const l = lcm(...d);

const n = setNumerators(l, lst);

const result = stringify(n);

return result.join("");

}

To further enhance this function, we can utilize the Array.reduce() method to streamline the common denominator calculation:

const cd = lst.reduce((a, [_, d]) => lcm(d, a), 1);

And we can also simplify how we calculate the new numerators:

const num = lst.map(([n, d]) => (${(n * cd) / d},${cd}));

With these adjustments, the final function looks like this:

const gcd = (a, b) => (b ? gcd(b, a % b) : a);

const lcm = (a, b) => (a * b) / gcd(a, b);

function convertFrac(lst) {

const cd = lst.reduce((a, [_, d]) => lcm(d, a), 1);

return lst.map(([n, d]) => (${(n * cd) / d},${cd})).join("");

}

Thank you for joining me in this exploration! Stay tuned for more insightful articles and programming tips.

In this video, "How to Find The LCD (Lowest Common Denominator) The EASY WAY," you will learn a simple method to find the lowest common denominator for fractions.

The video "Least Common Denominators (6 Examples)" provides six practical examples to help you understand the concept of least common denominators clearly.

More resources can be found at PlainEnglish.io. Be sure to sign up for our free weekly newsletter and follow us on social media!