Example of Big-Omega Ω Notation

Consider an example to print all the possible pairs of an array. The idea is to run two nested loops to generate all the possible pairs of the given array:

C++

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to print all possible pairs
int print(int a[], int n)
{
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (i != j)
                cout << a[i] << " " << a[j] << "\n";
        }
    }
}

// Driver Code
int main()
{

    // Given array
    int a[] = { 1, 2, 3 };

    // Store the size of the array
    int n = sizeof(a) / sizeof(a[0]);

    // Function Call
    print(a, n);

    return 0;
}

Java

// Java program for the above approach
import java.lang.*;
import java.util.*;

class GFG{

// Function to print all possible pairs
static void print(int a[], int n)
{
    for(int i = 0; i < n; i++) 
    {
        for(int j = 0; j < n; j++) 
        {
            if (i != j)
                System.out.println(a[i] + " " + a[j]);
        }
    }
}

// Driver code
public static void main(String[] args)
{
    
    // Given array
    int a[] = { 1, 2, 3 };

    // Store the size of the array
    int n = a.length;

    // Function Call
    print(a, n);
}
}

// This code is contributed by avijitmondal1998

// C# program for above approach
using System;

class GFG{


// Function to print all possible pairs
static void print(int[] a, int n)
{
    for(int i = 0; i < n; i++) 
    {
        for(int j = 0; j < n; j++) 
        {
            if (i != j)
                Console.WriteLine(a[i] + " " + a[j]);
        }
    }
}


// Driver Code
static void Main()
{
     // Given array
    int[] a = { 1, 2, 3 };

    // Store the size of the array
    int n = a.Length;

    // Function Call
    print(a, n);
}
}

// This code is contributed by sanjoy_62.

Javascript

<script>

// JavaScript program for the above approach

// Function to print all possible pairs
function print(a, n)
{
    for(let i = 0; i < n; i++) 
    {
        for(let j = 0; j < n; j++) 
        {
            if (i != j)
                document.write(a[i] + " " + 
                               a[j] + "<br>");
        }
    }
}

// Driver Code

// Given array
let a = [ 1, 2, 3 ];

// Store the size of the array
let n = a.length;

// Function Call
print(a, n);

// This code is contributed by code_hunt
 
</script>

Python3

# Python3 program for the above approach

# Function to print all possible pairs
def printt(a, n) :
    
    for i in range(n) :
        for j in range(n) :
            if (i != j) :
                print(a[i], "", a[j])

# Driver Code

# Given array
a = [ 1, 2, 3 ]

# Store the size of the array
n = len(a) 

# Function Call
printt(a, n)

# This code is contributed by splevel62.

Output

In this example, it is evident that the print statement gets executed n² times. Now linear functions g(n), logarithmic functions g(log n), constant functions g(1) will always grow at a lesser rate than n² when the input range tends to infinity therefore, the best-case running time of this program can be Ω(log n), Ω(n), Ω(1), or any function g(n) which is less than n²when n tends to infinity.

Analysis of Algorithms | Big-Omega Ω Notation

In the analysis of algorithms, asymptotic notations are used to evaluate the performance of an algorithm, in its best cases and worst cases. This article will discuss Big-Omega Notation represented by a Greek letter (Ω).

Table of Content

What is Big-Omega Ω Notation?
Definition of Big-Omega Ω Notation?
How to Determine Big-Omega Ω Notation?
Example of Big-Omega Ω Notation
When to use Big-Omega Ω notation?
Difference between Big-Omega Ω and Little-Omega ω notation
Frequently Asked Questions about Big-Omega Ω notation

Example of Big-Omega Ω Notation

Analysis of Algorithms | Big-Omega Ω Notation

Similar Reads

Contact Us