All Factors in Sorted Order

Given a natural number n, print all distinct divisors in sorted order.

Examples:

Input : n = 10
Output: 1 2 5 10

Input: n = 100
Output: 1 2 4 5 10 20 25 50 100

Input: n = 125
Output: 1 5 25 125

We have discussed how to find all the divisors of a number here: All Factors or Divisors

Table of Content

Using Two Arrays - O(√n) Time and O(√n) Space
Constant Extra Space - O(√n) Time and O(1) Space

Using Two Arrays - O(√n) Time and O(√n) Space

Check factors up to √n because factors come in pairs: n = a × b. When a is small (≤ √n), its pair b = n / a is large (≥ √n). So by iterating i from 1 to √n, we find one of the two factors as i and n/i.
When we iterate through factors, the smallest factor i gives the largest pair (n/i) as smaller value of i means larger value (n/i).
Storing smaller factors first and then adding larger factors in reverse gives all divisors in sorted order without sorting.
We need to handle perfect squares explicitly as we need to print all divisors only once.

C++

#include <iostream>
#include <vector>
#include <cmath>
using namespace std;

// returns all divisors of n in sorted order
vector<int> getDivisors(int n) {
    vector<int> small, large;
    int limit = sqrt(n);  // compute sqrt once

    for (int i = 1; i <= limit; i++) {
        if (n % i == 0) {

            // handle perfect square
            if (i == n / i) {
                small.push_back(i);
            } else {
                small.push_back(i);     // smaller divisor
                large.push_back(n / i); // paired larger divisor
            }
        }
    }

    // add larger divisors in reverse to keep sorted order
    for (int i = large.size() - 1; i >= 0; i--) {
        small.push_back(large[i]);
    }
    return small;
}

int main() {
    int n = 100;
    vector<int> res = getDivisors(n);

    for (int x : res) {
        cout << x << " ";
    }
    return 0;
}

#include <stdio.h>
#include <math.h>

// fills result[] with divisors in sorted order and returns count
int getDivisors(int n, int res[])
{
    int small[1000], large[1000];
    int s = 0, l = 0;

    int limit = sqrt(n); // compute sqrt once

    for (int i = 1; i <= limit; i++) {
        if (n % i == 0) {

            // perfect square case
            if (i == n / i) {
                small[s++] = i;
            } else {
                small[s++] = i;      // smaller divisor
                large[l++] = n / i;  // paired larger divisor
            }
        }
    }

    int k = 0;

    // copy small divisors
    for (int i = 0; i < s; i++)
        res[k++] = small[i];

    // append large divisors in reverse to keep sorted order
    for (int i = l - 1; i >= 0; i--)
        res[k++] = large[i];

    return k;
}

int main()
{
    int n = 100;
    int res[1000];

    int size = getDivisors(n, res);

    for (int i = 0; i < size; i++)
        printf("%d ", res[i]);

    return 0;
}

Java

import java.util.ArrayList;

class GFG {

    // returns all divisors of n in sorted order
    static ArrayList<Integer> getDivisors(int n) {
        ArrayList<Integer> small = new ArrayList<>();
        ArrayList<Integer> large = new ArrayList<>();

        int limit = (int) Math.sqrt(n); // compute sqrt once

        for (int i = 1; i <= limit; i++) {
            if (n % i == 0) {

                // handle perfect square
                if (i == n / i) {
                    small.add(i);
                } else {
                    small.add(i);       // smaller divisor
                    large.add(n / i);   // paired larger divisor
                }
            }
        }

        // add larger divisors in reverse to keep sorted order
        for (int i = large.size() - 1; i >= 0; i--) {
            small.add(large.get(i));
        }

        return small;
    }

    public static void main(String[] args) {
        int n = 100;

        ArrayList<Integer> res = getDivisors(n);

        // printing outside the function
        for (int x : res) {
            System.out.print(x + " ");
        }
    }
}

Python

import math

# returns divisors in sorted order
def getDivisors(n):
    small, large = [], []
    limit = int(math.sqrt(n))  # compute sqrt once

    for i in range(1, limit + 1):
        if n % i == 0:

            # perfect square case
            if i == n // i:
                small.append(i)
            else:
                small.append(i)        # smaller divisor
                large.append(n // i)   # paired larger divisor

    # append large divisors in reverse to keep sorted order
    return small + large[::-1]

if __name__ == "__main__": 
    n = 100
    res = getDivisors(n)

print(*res)

using System;
using System.Collections.Generic;

class GFG
{
    // returns divisors in sorted order
    static List<int> GetDivisors(int n)
    {
        List<int> small = new List<int>();
        List<int> large = new List<int>();

        int limit = (int)Math.Sqrt(n); // compute sqrt once

        for (int i = 1; i <= limit; i++)
        {
            if (n % i == 0)
            {
                // perfect square case
                if (i == n / i)
                    small.Add(i);
                else
                {
                    small.Add(i);       // smaller divisor
                    large.Add(n / i);   // paired larger divisor
                }
            }
        }

        // append large in reverse to keep sorted order
        for (int i = large.Count - 1; i >= 0; i--)
            small.Add(large[i]);

        return small;
    }

    static void Main()
    {
        int n = 100;
        var res = GetDivisors(n);

        foreach (var x in res)
            Console.Write(x + " "); 
    }
}

JavaScript

// returns divisors in sorted order
function getDivisors(n) {
    let small = [], large = [];
    let limit = Math.floor(Math.sqrt(n)); // compute sqrt once

    for (let i = 1; i <= limit; i++) {
        if (n % i === 0) {

            // perfect square case
            if (i === n / i) {
                small.push(i);
            } else {
                small.push(i);       // smaller divisor
                large.push(n / i);   // paired larger divisor
            }
        }
    }

    // append large divisors in reverse to keep sorted order
    return small.concat(large.reverse());
}

// Driver Code 
let n = 100;
let res = getDivisors(n);

console.log(res.join(" "));

Output

1 2 4 5 10 20 25 50 100

Constant Extra Space - O(√n) Time and O(1) Space

This is mainly a space optimization over the above approach. We first get the smaller factor of pairs in sorted order traversing i to √n. To get the larger factors in increasing order, we traverse back from i - 1 (which is around √n - 1) to 1 and instead of storing i, we store n/i so that we larger elements of pairs in increasing order.
For example, let n = 10.
Step 1: Loop from 1 → √n (√10 ≈ 3, so check only 1, 2, 3)
i = 1 ->10 % 1 == 0 -> print 1
i = 2 -> 10 % 2 == 0 -> print 2
i = 3 -> not divisible -> ignore
Step 2: i = i - 1, i = 2
Step 2: Traverse from 2 to 1
i = 2 -> 10 / 2 = 5 -> print 5
i = 1 -> 10 / 1 = 10 -> print 10
Final Output : 1, 2, 5, 10

C++

#include <cmath>
#include <iostream>
#include <vector>
using namespace std;

// returns divisors in sorted order (single vector approach)
vector<int> getDivisors(int n)
{
    vector<int> res;

    int i;

    // forward loop: collect small divisors
    for (i = 1; i * i < n; i++)
        if (n % i == 0)
            res.push_back(i); // smaller divisor

    // handle perfect square case
    if (i * i == n)
        res.push_back(i);
    i--;

    // backward loop: collect paired larger divisors
    for (; i >= 1; i--)
        if (n % i == 0)
            res.push_back(n / i); // paired larger divisor

    return res;
}

int main()
{
    int n = 100;

    vector<int> divisors = getDivisors(n);

    for (int x : divisors)
        cout << x << " ";

    return 0;
}