All Factors in Sorted Order (original) (raw)

Last Updated : 5 Apr, 2026

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 #include #include using namespace std;

// returns all divisors of n in sorted order vector getDivisors(int n) { vector 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 res = getDivisors(n);

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

}

C

#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)

C#

using System; using System.Collections.Generic;

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

    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 #include #include using namespace std;

// returns divisors in sorted order (single vector approach) vector getDivisors(int n) { vector 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;

}

Java

import java.util.ArrayList; import java.util.List;

// returns divisors in sorted order (single vector approach) public class Divisors { public static List getDivisors(int n) { List res = new ArrayList<>();

    int i;

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

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

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

    return res;
}

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

    List<Integer> divisors = getDivisors(n);

    for (int x : divisors)
        System.out.print(x + " ");
}

}

Python

import math

returns divisors in sorted order (single vector approach)

def getDivisors(n): res = []

i = 1

# forward loop: collect small divisors
while i * i < n:
    if n % i == 0:
        res.append(i) # smaller divisor
    i += 1

# handle perfect square case
if i * i == n:
    res.append(i)
i -= 1

# backward loop: collect paired larger divisors
while i >= 1:
    if n % i == 0:
        res.append(int(n / i)) # paired larger divisor
    i -= 1

return res

if name == 'main': n = 100

divisors = getDivisors(n)

for x in divisors:
    print(x, end=' ')

C#

using System; using System.Collections.Generic;

class Program { // returns divisors in sorted order (single vector approach) static List getDivisors(int n) { List res = new List(); int i;

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

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

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

    res.Sort();
    return res;
}

static void Main()
{
    int n = 100;

    List<int> divisors = getDivisors(n);

    foreach (int x in divisors)
        Console.Write(x + " ");
}

}

JavaScript

function getDivisors(n) { let res = []; let i;

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

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

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

return res.sort((a, b) => a - b);

}

let n = 100;

let divisors = getDivisors(n);

for (let x of divisors) console.log(x);

`

Output

1 2 4 5 10 20 25 50 100