Simplified Fractions - Practice Coding Problems

Simplified Fractions - Problem

Given an integer n, your task is to find all simplified fractions between 0 and 1 (exclusive) where the denominator is less than or equal to n.

A simplified fraction is one where the numerator and denominator have no common factors other than 1 (i.e., their greatest common divisor is 1). For example, 2/4 is not simplified because both 2 and 4 are divisible by 2, but 1/2 is simplified.

Examples:

For n = 2: Valid fractions are 1/2
For n = 3: Valid fractions are 1/2, 1/3, 2/3
For n = 4: Valid fractions are 1/2, 1/3, 1/4, 2/3, 3/4 (note: 2/4 is excluded as it's not simplified)

Return the fractions as strings in the format "numerator/denominator". The order of the result doesn't matter.

Input & Output

example_1.py — Basic Case

$ Input: n = 2

› Output: ["1/2"]

💡 Note: For denominator 2, only numerator 1 is valid since 1 < 2 and GCD(1,2) = 1

example_2.py — Multiple Fractions

$ Input: n = 3

› Output: ["1/2","1/3","2/3"]

💡 Note: For denominator 2: 1/2 is valid. For denominator 3: both 1/3 and 2/3 are valid since GCD(1,3)=1 and GCD(2,3)=1

example_3.py — With Non-simplified Fraction

$ Input: n = 4

› Output: ["1/2","1/3","1/4","2/3","3/4"]

💡 Note: All fractions from previous examples plus 1/4 and 3/4. Note that 2/4 is excluded because GCD(2,4)=2≠1, so it's not simplified

Constraints

1 ≤ n ≤ 100
The output can be in any order
All fractions must be in simplified form

Visualization

Tap to expand

Understanding the Visualization

Generate candidates

Create all possible fractions with denominators 2 through n

Apply GCD test

For each fraction, check if GCD(numerator, denominator) equals 1

Collect results

Keep only fractions that pass the GCD test (simplified fractions)

Format output

Convert to string format 'numerator/denominator'

Key Takeaway

🎯 Key Insight: A fraction a/b is in its simplest form if and only if GCD(a,b) = 1, meaning they share no common factors other than 1.

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The key to solving this problem is recognizing that a fraction is simplified when the Greatest Common Divisor (GCD) of numerator and denominator equals 1. The most straightforward approach uses nested loops to generate all possible fractions and filters them using GCD calculation, achieving O(n² log n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force with GCD Check	O(n² log n)	O(k)	Generate all possible fractions and filter using GCD

Brute Force with GCD Check — Algorithm Steps

Iterate through all possible denominators from 2 to n
For each denominator, iterate through all possible numerators from 1 to denominator-1
Calculate GCD of numerator and denominator
If GCD equals 1, the fraction is simplified - add it to result
Return all collected simplified fractions

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with denominator 2

Check numerator 1: GCD(1,2)=1 ✓ Add '1/2'

Move to denominator 3

Check numerators 1,2: GCD(1,3)=1 ✓, GCD(2,3)=1 ✓

Process denominator 4

Check numerators 1,2,3: Only GCD(1,4)=1 and GCD(3,4)=1 qualify

Continue pattern

For each denominator, test all smaller numerators using GCD

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int gcd(int a, int b) {
    while (b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

char** simplifiedFractions(int n, int* returnSize) {
    char** result = (char**)malloc(10000 * sizeof(char*));
    int count = 0;
    
    for (int denominator = 2; denominator <= n; denominator++) {
        for (int numerator = 1; numerator < denominator; numerator++) {
            if (gcd(numerator, denominator) == 1) {
                result[count] = (char*)malloc(20 * sizeof(char));
                sprintf(result[count], "%d/%d", numerator, denominator);
                count++;
            }
        }
    }
    
    *returnSize = count;
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    int returnSize;
    char** result = simplifiedFractions(n, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("\"%s\"", result[i]);
        if (i < returnSize - 1) printf(",");
        free(result[i]);
    }
    printf("]\n");
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

Two nested loops O(n²) with GCD calculation O(log n) for each pair

⚠ Quadratic Growth

Space Complexity

O(k)

Where k is the number of simplified fractions (output space)

✓ Linear Space

26.8K Views

Medium Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with GCD Check — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler