Open In App

Number of quadrilateral formed with N distinct points on circumference of Circle

Given an integer N which denotes the points on the circumference of a circle, the task is to find the number of quadrilaterals formed using these points.
Examples: 
 

Input: N = 5 
Output: 5
Input: N = 10 
Output: 210 
 


 


Approach: The idea is to use permutation and combination to find the number of possible quadrilaterals using the N points on the circumference of the circle. The number of possible quadrilaterals will be .
Below is the implementation of the above approach:
 

// C++ implementation to find the
// number of quadrilaterals formed
// with N distinct points
#include<bits/stdc++.h>
using namespace std;
 
// Function to find the factorial
// of the given number N
int fact(int n)
{
    int res = 1;
 
    // Loop to find the factorial
    // of the given number
    for(int i = 2; i < n + 1; i++)
       res = res * i;
        
    return res;
}
 
// Function to find the number of
// combinations in the N
int nCr(int n, int r)
{
    return (fact(n) / (fact(r) *
                       fact(n - r)));
}
 
// Driver Code
int main()
{
    int n = 5;
 
    // Function Call
    cout << (nCr(n, 4));
}
 
// This code is contributed by rock_cool

                    
// Java implementation to find the
// number of quadrilaterals formed
// with N distinct points
class GFG{
     
// Function to find the number of
// combinations in the N
static int nCr(int n, int r)
{
    return (fact(n) / (fact(r) *
                       fact(n - r)));
}
 
// Function to find the factorial
// of the given number N
static int fact(int n)
{
    int res = 1;
 
    // Loop to find the factorial
    // of the given number
    for(int i = 2; i < n + 1; i++)
        res = res * i;
    return res;
}
 
// Driver Code
public static void main(String[] args)
{
    int n = 5;
 
    // Function Call
    System.out.println(nCr(n, 4));
}
}
 
// This code is contributed by 29AjayKumar

                    
# Python3 implementation to find the
# number of quadrilaterals formed
# with N distinct points
 
# Function to find the number of
# combinations in the N
def nCr(n, r):
    return (fact(n) / (fact(r)
                * fact(n - r)))
 
# Function to find the factorial
# of the given number N
def fact(n):
    res = 1
     
    # Loop to find the factorial
    # of the given number
    for i in range(2, n + 1):
        res = res * i    
    return res
 
# Driver Code
if __name__ == "__main__":
    n = 5
     
    # Function Call
    print(int(nCr(n, 4)))

                    
// C# implementation to find the
// number of quadrilaterals formed
// with N distinct points
using System;
class GFG{
     
// Function to find the number of
// combinations in the N
static int nCr(int n, int r)
{
    return (fact(n) / (fact(r) *
                       fact(n - r)));
}
 
// Function to find the factorial
// of the given number N
static int fact(int n)
{
    int res = 1;
 
    // Loop to find the factorial
    // of the given number
    for(int i = 2; i < n + 1; i++)
        res = res * i;
    return res;
}
 
// Driver Code
public static void Main(String[] args)
{
    int n = 5;
 
    // Function Call
    Console.Write(nCr(n, 4));
}
}
 
// This code is contributed by shivanisinghss2110

                    
<script>
 
// JavaScript implementation to find the
// number of quadrilaterals formed
// with N distinct points
 
// Function to find the factorial
// of the given number N
function fact(n)
{
    let res = 1;
 
    // Loop to find the factorial
    // of the given number
    for(let i = 2; i < n + 1; i++)
    res = res * i;
         
    return res;
}
 
// Function to find the number of
// combinations in the N
function nCr(n, r)
{
    return (fact(n) / (fact(r) *
                    fact(n - r)));
}
 
// Driver Code
 
    let n = 5;
 
    // Function Call
    document.write(nCr(n, 4));
 
// This code is contributed by Surbhi Tyagi.
 
</script>

                    

Output
5





Using nested loops :

Approach:

We can iterate over all possible combinations of 4 points and check if they form a quadrilateral. To check if a set of 4 points form a quadrilateral, we can check if any three points are not collinear. This can be done by checking if the cross product of two vectors formed by any three points is non-zero.

Define a function named count_quadrilaterals_2 that takes an integer argument N representing the number of distinct points on the circumference of the circle.
Initialize a variable count to 0 to keep track of the number of quadrilaterals.
Create a list points containing the integers from 0 to N-1 representing the distinct points on the circle.
Use four nested loops to iterate over all possible combinations of 4 points:
Loop over i from 0 to N-1
Loop over j from i+1 to N-1
Loop over k from j+1 to N-1
Loop over l from k+1 to N-1
Check if the four selected points (points[i], points[j], points[k], points[l]) form a quadrilateral:
Check if any three points are not collinear by computing the cross product of any two vectors formed by the three points.
If the cross products are non-zero, increment the count variable.
Return the final value of count.

#include <iostream>
using namespace std;
 
int GFG(int N) {
    int count = 0;
    int points[N];
    for (int i = 0; i < N; i++) {
        points[i] = i;
    }
    // Loop through all possible
    // combinations of 4 points
    for (int i = 0; i < N; i++) {
        for (int j = i + 1; j < N; j++) {
            for (int k = j + 1; k < N; k++) {
                for (int l = k + 1; l < N; l++) {
                    // Check if any three points are not collinear
                    if ((points[j] - points[i]) * (points[k] - points[i]) != 0 &&
                        (points[j] - points[i]) * (points[l] - points[i]) != 0 &&
                        (points[k] - points[j]) * (points[l] - points[j]) != 0) {
                        count++;
                    }
                }
            }
        }
    }
 
    return count;
}
int main() {
    cout << GFG(5) << endl;
    cout << GFG(10) << endl;
    return 0;
}

                    
import java.util.Arrays;
 
class CollinearPoints {
    // Function to count the number of ways to choose 4
    // non-collinear points
    static int countNonCollinearPoints(int N)
    {
        int count = 0;
        int[] points = new int[N];
 
        // Initialize points with indices
        for (int i = 0; i < N; i++) {
            points[i] = i;
        }
 
        // Loop through all possible combinations of 4
        // points
        for (int i = 0; i < N; i++) {
            for (int j = i + 1; j < N; j++) {
                for (int k = j + 1; k < N; k++) {
                    for (int l = k + 1; l < N; l++) {
                        // Check if any three points are not
                        // collinear
                        if ((points[j] - points[i])
                                    * (points[k]
                                       - points[i])
                                != 0
                            && (points[j] - points[i])
                                       * (points[l]
                                          - points[i])
                                   != 0
                            && (points[k] - points[j])
                                       * (points[l]
                                          - points[j])
                                   != 0) {
                            count++;
                        }
                    }
                }
            }
        }
 
        return count;
    }
 
    public static void main(String[] args)
    {
        System.out.println(countNonCollinearPoints(5));
        System.out.println(countNonCollinearPoints(10));
    }
}

                    
def count_quadrilaterals_2(N):
    count = 0
    points = [i for i in range(N)]
    for i in range(N):
        for j in range(i+1, N):
            for k in range(j+1, N):
                for l in range(k+1, N):
                    # Check if any three points are not collinear
                    if (points[j]-points[i])*(points[k]-points[i]) != 0 and \
                       (points[j]-points[i])*(points[l]-points[i]) != 0 and \
                       (points[k]-points[j])*(points[l]-points[j]) != 0:
                        count += 1
    return count
     
# Example usage
print(count_quadrilaterals_2(5)) # Output: 5
print(count_quadrilaterals_2(10)) # Output: 210

                    
using System;
 
class Program
{
    static int GFG(int N)
    {
        int count = 0;
        int[] points = new int[N];
         
        // Initialize the points array
        for (int i = 0; i < N; i++)
        {
            points[i] = i;
        }
 
        // Loop through all possible combinations of 4 points
        for (int i = 0; i < N; i++)
        {
            for (int j = i + 1; j < N; j++)
            {
                for (int k = j + 1; k < N; k++)
                {
                    for (int l = k + 1; l < N; l++)
                    {
                        // Check if any three points are not collinear
                        if ((points[j] - points[i]) * (points[k] - points[i]) != 0 &&
                            (points[j] - points[i]) * (points[l] - points[i]) != 0 &&
                            (points[k] - points[j]) * (points[l] - points[j]) != 0)
                        {
                            count++;
                        }
                    }
                }
            }
        }
 
        return count;
    }
// Driver code
    static void Main(string[] args)
    {
        Console.WriteLine(GFG(5));
        Console.WriteLine(GFG(10));
    }
}

                    
function countQuadruples(N) {
    let count = 0;
    const points = new Array(N);
 
    // Initialize an array with values [0, 1, 2, ..., N-1]
    for (let i = 0; i < N; i++) {
        points[i] = i;
    }
 
    // Loop through all possible combinations of 4 points
    for (let i = 0; i < N; i++) {
        for (let j = i + 1; j < N; j++) {
            for (let k = j + 1; k < N; k++) {
                for (let l = k + 1; l < N; l++) {
                    // Check if any three points are not collinear
                    if (
                        (points[j] - points[i]) * (points[k] - points[i]) !== 0 &&
                        (points[j] - points[i]) * (points[l] - points[i]) !== 0 &&
                        (points[k] - points[j]) * (points[l] - points[j]) !== 0
                    ) {
                        count++;
                    }
                }
            }
        }
    }
 
    return count;
}
 
// Example usage:
console.log(countQuadruples(5)); // Output: 10
console.log(countQuadruples(10)); // Output: 210

                    

Output
5
210





Time Complexity: O(N^4)
Auxiliary Space: O(1)


Article Tags :