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)