Farey Sequence (original) (raw)

Last Updated : 23 Jul, 2025

**Farey sequence is a sequence which is generated for order n. The sequence has all rational numbers in the range [0/0 to 1/1] sorted in increasing order such that the denominators are less than or equal to n and all numbers are in reduced forms i.e., 4/4 cannot be there as it can be reduced to 1/1.

For order n, the function is denoted as **F n.

How to Construct Farey Sequence?

To construct the Farey Sequence of order n:

  1. Start with 0/1 and 1/1.
  2. Insert fractions between 0/1 and 1/1, ensuring:
    • The denominator is less than or equal to n.
    • Fractions are in their simplest form.
  3. Arrange the fractions in ascending order.

**Examples:

F1 = 0/1, 1/1 F2 = 0/1, 1/2, 1/1 F3 = 0/1, 1/3, 1/2, 2/3, 1/1 . . FFord = 0/1, 1/7, 1/6, 1/5, 1/4, 2/7, 1/3, 2/5, 3/7, 1/2, 4/7, 3/5, 2/3, 5/7, 3/4, 4/5, 5/6, 6/7, 1/1

Farey sequence is used in rational approximations of irrational numbers, Ford circles and in Riemann hypothesis.

**How to generate a Farey Sequence of given order?

The idea is simple, we consider every possible rational number from 1/1 to n/n. And for every generated rational number, we check if it is in reduced form. If yes, then we add it to Farey Sequence. A rational number is in reduced form if GCD of numerator and denominator is 1.
Below is the implementation based on above idea.

C++ `

// C++ program to print Farey Sequence of given order #include <bits/stdc++.h> using namespace std;

// class for x/y (a term in farey sequence class Term { public: int x, y;

// Constructor to initialize x and y in x/y
Term(int x, int y)
    : x(x), y(y)
{
}

};

// Comparison function for sorting bool cmp(Term a, Term b) { // Comparing two ratio return a.x * b.y < b.x * a.y; }

// GCD of a and b int gcd(int a, int b) { if (b == 0) return a; return gcd(b, a % b); }

// Function to print Farey sequence of order n void farey(int n) { // Create a vector to store terms of output vector v;

// One by one find and store all terms except 0/1 and n/n
// which are known
for (int i = 1; i <= n; ++i) {
    for (int j = i + 1; j <= n; ++j)

        // Checking whether i and j are in lowest term
        if (gcd(i, j) == 1)
            v.push_back(Term(i, j));
}

// Sorting the term of sequence
sort(v.begin(), v.end(), cmp);

// Explicitly printing first term
cout << "0/1 ";

// Printing other terms
for (int i = 0; i < v.size(); ++i)
    cout << v[i].x << "/" << v[i].y << " ";

// explicitly printing last term
cout << "1/1";

}

// Driver program int main() { int n = 7; cout << "Farey Sequence of order " << n << " is\n"; farey(n); return 0; }

Java

// Java program to print Farey Sequence of given order

import java.util.*;

// class for x/y (a term in farey sequence class Term { public int x, y;

// Constructor to initialize x and y in x/y
public Term(int x1, int y1)
{
    this.x = x1;
    this.y = y1;
}

};

public class GFG {

// GCD of a and b
static int gcd(int a, int b)
{
    if (b == 0)
        return a;
    return gcd(b, a % b);
}

// Function to print Farey sequence of order n
static void farey(int n)
{
    // Create a vector to store terms of output
    ArrayList<Term> v = new ArrayList<Term>();

    // One by one find and store all terms except 0/1
    // and n/n which are known
    for (int i = 1; i <= n; ++i) {
        for (int j = i + 1; j <= n; ++j)

            // Checking whether i and j are in lowest
            // term
            if (gcd(i, j) == 1)
                v.add(new Term(i, j));
    }

    // Sorting the term of sequence
    Collections.sort(v, new Comparator<Term>() {
        // Comparison function for sorting
        public int compare(Term a, Term b)
        {
            // Comparing two ratio
            return a.x * b.y - b.x * a.y;
        }
    });

    // Explicitly printing first term
    System.out.print("0/1 ");

    // Printing other terms
    for (int i = 0; i < v.size(); ++i)
        System.out.print(v.get(i).x + "/" + v.get(i).y
                         + " ");

    // explicitly printing last term
    System.out.print("1/1");
}

// Driver program
public static void main(String[] args)
{
    int n = 7;
    System.out.print("Farey Sequence of order " + n
                     + " is\n");
    farey(n);
}

}

// This code is contributed by phasing17

Python3

Python3 program to print

Farey Sequence of given order

class for x/y (a term in farey sequence

class Term:

# Constructor to initialize
# x and y in x/y
def __init__(self, x, y):
    self.x = x
    self.y = y

GCD of a and b

def gcd(a, b): if b == 0: return a return gcd(b, a % b)

Function to print

Farey sequence of order n

def farey(n):

# Create a vector to 
# store terms of output
v = []

# One by one find and store 
# all terms except 0/1 and n/n
# which are known
for i in range(1, n + 1):
    for j in range(i + 1, n + 1):

        # Checking whether i and j
        # are in lowest term
        if gcd(i, j) == 1:
            v.append(Term(i, j))

# Sorting the term of sequence
for i in range(len(v)):
    for j in range(i + 1, len(v)):
        if (v[i].x * v[j].y > v[j].x * v[i].y):
            v[i], v[j] = v[j], v[i]

# Explicitly printing first term
print("0/1", end = " ")

# Printing other terms
for i in range(len(v)):
    print("%d/%d" % (v[i].x, 
                    v[i].y), end = " ")

# explicitly printing last term
print("1/1")

Driver Code

if name == "main": n = 7 print("Farey sequence of order %d is" % n) farey(n)

This code is contributed by

sanjeev2552

C#

// C# program to print Farey Sequence of given order using System; using System.Collections.Generic;

class TermComparer : Comparer {

// Comparison function for sorting
public override int Compare(Term a, Term b)
{
    // Comparing two ratio
    return a.x * b.y - b.x * a.y;
}

}

// class for x/y (a term in farey sequence class Term { public int x, y;

// Constructor to initialize x and y in x/y
public Term(int x1, int y1)
{
    this.x = x1;
    this.y = y1;
}

};

public class GFG {

// GCD of a and b static int gcd(int a, int b) { if (b == 0) return a; return gcd(b, a % b); }

// Function to print Farey sequence of order n static void farey(int n) { // Create a vector to store terms of output List v = new List();

// One by one find and store all terms except 0/1
// and n/n which are known
for (int i = 1; i <= n; ++i) {
  for (int j = i + 1; j <= n; ++j)

    // Checking whether i and j are in lowest
    // term
    if (gcd(i, j) == 1)
      v.Add(new Term(i, j));
}

// Sorting the term of sequence
v.Sort(new TermComparer());

// Explicitly printing first term
Console.Write("0/1 ");

// Printing other terms
for (int i = 0; i < v.Count; ++i)
  Console.Write(v[i].x + "/" + v[i].y + " ");

// explicitly printing last term
Console.Write("1/1");

}

// Driver program public static void Main(string[] args) { int n = 7; Console.Write("Farey Sequence of order " + n + " is\n"); farey(n); } }

// This code is contributed by phasing17

JavaScript

`

**Output:

Farey Sequence of order 7 is 0/1 1/7 1/6 1/5 1/4 2/7 1/3 2/5 3/7 1/2 4/7 3/5 2/3 5/7 3/4 4/5 5/6 6/7 1/1

Time complexity of above approach is O(n2 Log n) where O(log n) is an upper bound on time taken by Euclid's algorithm for GCD.
Farey Sequence has below properties [See wiki for details]
A term x/y can be recursively evaluated using previous two terms. Below is the formula to compute xn+2/yn+2 from xn+1/yn+1 and xn/yn.

x[n+2] = floor((y[n]+n) / y[n+1])x[n+1]– x[n]
y[n+2] = floor((y[n]+n) / y[n+1])y[n+1]– y[n]

We can use above properties to optimize.

C++ `

// Efficient C++ program to print Farey Sequence of order n #include <bits/stdc++.h> using namespace std;

// Optimized function to print Farey sequence of order n void farey(int n) { // We know first two terms are 0/1 and 1/n double x1 = 0, y1 = 1, x2 = 1, y2 = n;

printf("%.0f/%.0f %.0f/%.0f", x1, y1, x2, y2);

double x, y = 0; // For next terms to be evaluated
while (y != 1.0) {
    // Using recurrence relation to find the next term
    x = floor((y1 + n) / y2) * x2 - x1;
    y = floor((y1 + n) / y2) * y2 - y1;

    // Print next term
    printf(" %.0f/%.0f", x, y);

    // Update x1, y1, x2 and y2 for next iteration
    x1 = x2, x2 = x, y1 = y2, y2 = y;
}

}

// Driver program int main() { int n = 7; cout << "Farey Sequence of order " << n << " is\n"; farey(n); return 0; }

Java

// Efficient Java program to print // Farey Sequence of order n class GFG {

// Optimized function to print // Farey sequence of order n static void farey(int n) { // We know first two terms are 0/1 and 1/n double x1 = 0, y1 = 1, x2 = 1, y2 = n;

System.out.printf("%.0f/%.0f %.0f/%.0f", x1, y1, x2, y2);

double x, y = 0; // For next terms to be evaluated
while (y != 1.0) 
{
    // Using recurrence relation to find the next term
    x = Math.floor((y1 + n) / y2) * x2 - x1;
    y = Math.floor((y1 + n) / y2) * y2 - y1;

    // Print next term
    System.out.printf(" %.0f/%.0f", x, y);

    // Update x1, y1, x2 and y2 for next iteration
    x1 = x2;
    x2 = x;
    y1 = y2;
    y2 = y;
}

}

// Driver program public static void main(String[] args) { int n = 7; System.out.print("Farey Sequence of order " + n + " is\n"); farey(n); } }

// This code is contributed by Rajput-Ji

Python3

Efficient Python3 program to print

Farey Sequence of order n

import math

Optimized function to print Farey

sequence of order n

def farey(n):

# We know first two terms are 
# 0/1 and 1/n
x1 = 0; 
y1 = 1; 
x2 = 1; 
y2 = n;

print(x1, end = "") 
print("/", end = "")
print(y1, x2, end = "") 
print("/", end = "") 
print(y2, end = " ");

# For next terms to be evaluated
x = 0;
y = 0; 
while (y != 1.0):
    
    # Using recurrence relation to
    # find the next term
    x = math.floor((y1 + n) / y2) * x2 - x1;
    y = math.floor((y1 + n) / y2) * y2 - y1;

    # Print next term
    print(x, end = "")
    print("/", end = "")
    print(y, end = " ");

    # Update x1, y1, x2 and y2 for 
    # next iteration
    x1 = x2; 
    x2 = x; 
    y1 = y2; 
    y2 = y;

Driver Code

n = 7; print("Farey Sequence of order", n, "is"); farey(n);

This code is contributed by mits

C#

// Efficient C# program to print // Farey Sequence of order n using System;

public class GFG {

// Optimized function to print // Farey sequence of order n static void farey(int n) { // We know first two terms are 0/1 and 1/n double x1 = 0, y1 = 1, x2 = 1, y2 = n;

Console.Write("{0:F0}/{1:F0} {2:F0}/{3:F0}", x1, y1, x2, y2);

double x, y = 0; // For next terms to be evaluated
while (y != 1.0) 
{
    // Using recurrence relation to find the next term
    x = Math.Floor((y1 + n) / y2) * x2 - x1;
    y = Math.Floor((y1 + n) / y2) * y2 - y1;

    // Print next term
    Console.Write(" {0:F0}/{1:F0}", x, y);

    // Update x1, y1, x2 and y2 for next iteration
    x1 = x2;
    x2 = x;
    y1 = y2;
    y2 = y;
}

}

// Driver program public static void Main(String[] args) { int n = 7; Console.Write("Farey Sequence of order " + n + " is\n"); farey(n); } }

// This code is contributed by 29AjayKumar

JavaScript

PHP

y2=y2 = y2=n; echo x1,"/",x1, "/", x1,"/",y1, " ", $x2, "/", $y2, " "; // For next terms // to be evaluated $x; $y = 0; while ($y != 1.0) { // Using recurrence relation to // find the next term x=floor((x = floor((x=floor((y1 + n)/n) / n)/y2) * x2−x2 - x2−x1; y=floor((y = floor((y=floor((y1 + n)/n) / n)/y2) * y2−y2 - y2−y1; // Print next term echo x,"/",x, "/", x,"/",y, " "; // Update x1, y1, x2 and // y2 for next iteration x1=x1 = x1=x2; x2=x2 = x2=x; y1=y1 = y1=y2; y2=y2 = y2=y; } } // Driver Code $n = 7; echo "Farey Sequence of order ", $n, " is\n"; farey($n); // This code is contributed by ajit ?>

`

**Output:

Farey Sequence of order 7 is 0/1 1/7 1/6 1/5 1/4 2/7 1/3 2/5 3/7 1/2 4/7 3/5 2/3 5/7 3/4 4/5 5/6 6/7 1/1

Time Complexity of this solution is O(n).