Open In App

Number of parallelograms when n horizontal parallel lines intersect m vertical parallel lines

Last Updated : 12 Nov, 2023
Improve
Improve
Like Article
Like
Save
Share
Report

Given two positive integers n and m. The task is to count number of parallelogram that can be formed of any size when n horizontal parallel lines intersect with m vertical parallel lines. 
 

Examples: 
 

Input : n = 3, m = 2
Output : 3
2 parallelograms of size 1x1 and 1 parallelogram
of size 2x1.
Input : n = 5, m = 5
Output : 100

 

The idea is to use Combination, which state, number of ways to choose k items from given n items is given by nCr
To form a parallelogram, we need two horizontal parallel lines and two vertical parallel lines. So, number of ways to choose two horizontal parallel lines are nC2 and number of ways to choose two vertical parallel lines are mC2. So, total number of possible parallelogram will be nC2 x mC2.
Below is C++ implementation of this approach: 
 

C++




// CPP Program to find number of parallelogram when
// n horizontal parallel lines intersect m vertical
// parallel lines.
#include<bits/stdc++.h>
#define MAX 10
using namespace std;
 
// Find value of Binomial Coefficient
int binomialCoeff(int C[][MAX], int n, int k)
{
    // Calculate value of Binomial Coefficient
    // in bottom up manner
    for (int i = 0; i <= n; i++)
    {
        for (int j = 0; j <= min(i, k); j++)
        {
            // Base Cases
            if (j == 0 || j == i)
                C[i][j] = 1;
  
            // Calculate value using previously
            // stored values
            else
                C[i][j] = C[i-1][j-1] + C[i-1][j];
        }
    }
}
 
// Return number of parallelogram when n horizontal
// parallel lines intersect m vertical parallel lines.
int countParallelogram(int n, int m)
{
    int  C[MAX][MAX] = { 0 };   
    binomialCoeff(C, max(n, m), 2);   
    return C[n][2] * C[m][2];
}
 
// Driver Program
int main()
{
    int n = 5, m = 5;   
    cout << countParallelogram(n, m) << endl;
    return 0;
}


Java




// Java Program to find number of parallelogram when
// n horizontal parallel lines intersect m vertical
// parallel lines.
class GFG
{
    static final int MAX = 10;
     
    // Find value of Binomial Coefficient
    static void binomialCoeff(int C[][], int n, int k)
    {
        // Calculate value of Binomial Coefficient
        // in bottom up manner
        for (int i = 0; i <= n; i++)
        {
            for (int j = 0; j <= Math.min(i, k); j++)
            {
                // Base Cases
                if (j == 0 || j == i)
                    C[i][j] = 1;
     
                // Calculate value using previously
                // stored values
                else
                    C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
            }
        }
    }
     
    // Return number of parallelogram when n horizontal
    // parallel lines intersect m vertical parallel lines.
    static int countParallelogram(int n, int m)
    {
        int C[][]=new int[MAX][MAX];
         
        binomialCoeff(C, Math.max(n, m), 2);
         
        return C[n][2] * C[m][2];
    }
     
    // Driver code
    public static void main(String arg[])
    {
        int n = 5, m = 5;
        System.out.println(countParallelogram(n, m));
    }
}
 
// This code is contributed By Anant Agarwal.


Python3




# Python Program to find number of parallelogram when
# n horizontal parallel lines intersect m vertical
# parallel lines.
MAX = 10;
 
# Find value of Binomial Coefficient
def binomialCoeff(C, n, k):
     
    # Calculate value of Binomial Coefficient
    # in bottom up manner
    for i in range(n + 1):
        for j in range(0, min(i, k) + 1):
         
            # Base Cases
            if (j == 0 or j == i):
                C[i][j] = 1;
 
            # Calculate value using previously
            # stored values
            else:
                C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
 
# Return number of parallelogram when n horizontal
# parallel lines intersect m vertical parallel lines.
def countParallelogram(n, m):
    C = [[0 for i in range(MAX)] for j in range(MAX)]
 
    binomialCoeff(C, max(n, m), 2);
 
    return C[n][2] * C[m][2];
 
# Driver code
if __name__ == '__main__':
    n = 5;
    m = 5;
    print(countParallelogram(n, m));
 
# This code is contributed by 29AjayKumar


C#




// C# Program to find number of parallelogram when
// n horizontal parallel lines intersect m vertical
// parallel lines.
using System;
 
class GFG
{
    static int MAX = 10;
     
    // Find value of Binomial Coefficient
    static void binomialCoeff(int [,]C, int n, int k)
    {
        // Calculate value of Binomial Coefficient
        // in bottom up manner
        for (int i = 0; i <= n; i++)
        {
            for (int j = 0; j <= Math.Min(i, k); j++)
            {
                // Base Cases
                if (j == 0 || j == i)
                    C[i, j] = 1;
     
                // Calculate value using previously
                // stored values
                else
                    C[i, j] = C[i - 1, j - 1] + C[i - 1, j];
            }
        }
    }
     
    // Return number of parallelogram when n horizontal
    // parallel lines intersect m vertical parallel lines.
    static int countParallelogram(int n, int m)
    {
        int [,]C = new int[MAX, MAX];
         
        binomialCoeff(C, Math.Max(n, m), 2);
         
        return C[n, 2] * C[m, 2];
    }
     
    // Driver code
    public static void Main()
    {
        int n = 5, m = 5;
        Console.WriteLine(countParallelogram(n, m));
    }
}
 
// This code is contributed By vt_m.


Javascript




<script>
 
// Javascript Program to find number of parallelogram when
// n horizontal parallel lines intersect m vertical
// parallel lines.
var MAX = 10;
 
// Find value of Binomial Coefficient
function binomialCoeff(C, n, k)
{
    // Calculate value of Binomial Coefficient
    // in bottom up manner
    for (var i = 0; i <= n; i++)
    {
        for (var j = 0; j <= Math.min(i, k); j++)
        {
            // Base Cases
            if (j == 0 || j == i)
                C[i][j] = 1;
  
            // Calculate value using previously
            // stored values
            else
                C[i][j] = C[i-1][j-1] + C[i-1][j];
        }
    }
}
 
// Return number of parallelogram when n horizontal
// parallel lines intersect m vertical parallel lines.
function countParallelogram(n, m)
{
    var C = Array.from(Array(MAX), () => Array(MAX).fill(0));
    binomialCoeff(C, Math.max(n, m), 2);   
    return C[n][2] * C[m][2];
}
 
// Driver Program
var n = 5, m = 5;   
document.write( countParallelogram(n, m));
 
// This code is contributed by rdtank.
</script>


Output

100








Time Complexity: O(n2
Auxiliary Space: O(n2)

Approach: Using Basic Maths

The same Question can be Solved By just using the basic maths
as we know nC2 = n*(n-1)/2 and same for mC2 so just using basic maths we can solve the question in O(1)

Below is the implementation of the above approach:

C++




#include <iostream>
 
class GFG {
public:
    static int findtheParallelogram(int n, int m)
    {
        // as nC2 = (n*(n-1))/2
        int result
            = ((n * (n - 1)) / 2) * ((m * (m - 1)) / 2);
 
        return result;
    }
};
 
int main()
{
    int n = 5;
    int m = 5;
    std::cout << GFG::findtheParallelogram(n, m)
              << std::endl;
    return 0;
}


Java




import java.io.*;
 
class GFG {
   public static int findtheParallelogram(int n, int m) {
     //as nC2 = (n*(n-1))/2
    int result = ((n * (n - 1)) / 2) * ((m * (m - 1)) / 2);
      
    return result;
  }
  //Driver code
  public static void main(String[] vars){
    int n = 5;
    int  m =5;
    System.out.println(findtheParallelogram(n,m));
  }
}


Python3




def find_the_parallelogram(n, m):
    # Calculate the number of parallelograms using the formula:
    # nC2 = (n * (n - 1)) / 2
    # mC2 = (m * (m - 1)) / 2
    result = ((n * (n - 1)) // 2) * ((m * (m - 1)) // 2)
    return result
 
# Driver code
if __name__ == "__main__":
    n = 5
    m = 5
    print(find_the_parallelogram(n, m))


C#




using System;
 
class GFG {
    // This method calculates the number of parallelograms
    // that can be formed given the dimensions n and m,
    // where n and m are the number of rows and columns.
    public static int FindTheParallelogram(int n, int m)
    {
        // Calculate nC2 = (n * (n - 1)) / 2
        // This formula represents the number of ways to
        // choose 2 items from n. For a parallelogram, we
        // need to choose 2 rows from n and 2 columns from
        // m.
        int result
            = ((n * (n - 1)) / 2) * ((m * (m - 1)) / 2);
 
        return result;
    }
}
 
class Program {
    static void Main(string[] args)
    {
        int n = 5;
        int m = 5;
 
        // Calculate and display the number of
        // parallelograms that can be formed with the given
        // dimensions n and m.
        Console.WriteLine("Number of Parallelograms: "
                          + GFG.FindTheParallelogram(n, m));
    }
}


Javascript




class GFG {
    static findtheParallelogram(n, m) {
        // Calculate the result using the formula
        // nC2 = (n * (n-1)) / 2
        const result = ((n * (n - 1)) / 2) * ((m * (m - 1)) / 2);
 
        return result;
    }
}
 
// Entry point
const n = 5;
const m = 5;
console.log(GFG.findtheParallelogram(n, m));


Output

100








Time Complexity :O(1)
Space Complexity : O(1)
This article is contributed by Aarti_Rathi and Dhruv Khoradiya.
 



Previous Article
Next Article

Similar Reads

Total number of triangles formed when there are H horizontal and V vertical lines
Given a triangle ABC. H horizontal lines from side AB to AC (as shown in fig.) and V vertical lines from vertex A to side BC are drawn, the task is to find the total no. of triangles formed.Examples: Input: H = 2, V = 2 Output: 18 As we see in the image above, total triangles formed are 18.Input: H = 3, V = 4 Output: 60 Approach: As we see in the i
5 min read
Check if N given lines can be intersected by K vertical lines
Given N horizontal lines represented by an array position[][] of size N, where position[i] represents the ith horizontal line which has x-coordinates from position[i][0] to position[i][1] and an integer K, which represents the maximum number of vertical lines that can be drawn, the task is to check if N given lines can be intersected by at most K v
6 min read
Number of horizontal or vertical line segments to connect 3 points
Given three points on the x-y coordinate plane. You need to find the no. of line segments formed by making a polyline passing through these points. (Line segment can be vertically or horizontally aligned to the coordinate axis) Examples : Input : A = {-1, -1}, B = {-1, 3}, C = {4, 3} Output : 2 Expantaion: There are two segments in this polyline. I
8 min read
Count cells in a grid from which maximum number of cells can be reached by K vertical or horizontal jumps
Given a matrix mat[][] of dimensions N*M and a positive integer K, the task is to find the number of cells in a grid from which maximum cells can be reached by K jumps in the vertical or horizontal direction. Examples: Input: N = 3, M = 3, K = 2Output: 4Explanation:The cells represented as X are the cells from which maximum cells (= 2) can be reach
8 min read
Count number of triangles cut by the given horizontal and vertical line segments
Given an array triangles[][] consisting of N triangles of the form {x1, y1, x2, y2, x3, y3} and an array cuts[] consisting of M horizontal and vertical lines of the form "X=x" or "Y=y" which represents the equation of the line segments. The task is to print the number of triangles intersected by each cut in such a way that the left and the right pa
13 min read
Finding the number of triangles amongst horizontal and vertical line segments
Prerequisites: BIT Given 'n' line segments, each of them is either horizontal or vertical, find the maximum number of triangles(including triangles with zero area) that can be formed by joining the intersection points of the line segments. No two horizontal line segments overlap, nor do two vertical line segments. A line is represented using two po
6 min read
Maximum number of parallelograms that can be made using the given length of line segments
Given N line segments where the length of the ith line segment is [Tex]a_i [/Tex]. The task is to find the maximum number of parallelograms can be made with those line segments if each line segment is used at most in one parallelogram.Examples: Input: arr[] = {1, 2, 1, 2} Output: 1 Only one parallelogram can be made with sides 1, 2, 1, 2 Input: arr
6 min read
Vertical and Horizontal retrieval (MRT) on Tapes
Prerequisite: Optimal Storage on Tapes You are given tapes[] of different sizes and records[] of different volumes. The task is to fill the volumes in tapes horizontally or vertically such that Retrieval Time is minimised. Examples: Input: tape[] = { 25, 80, 160}, records[] = { 15, 2, 8, 23, 45, 50, 60, 120 } Output: Horizontal Filling: 1st tape :
22 min read
Count ways to remove pairs from a matrix such that remaining elements can be grouped in vertical or horizontal pairs
Given an integer K and a square matrix mat[][] of size N * N with elements from the range[1, K], the task is to count ways to remove pairs of distinct matrix elements such that remaining elements can be arranged in pairs vertically or horizontally. Examples: Input: mat[][] = {{1, 2}, {3, 4}}, K = 4Output: 4Explanation:Remove the row {1, 2}. Therefo
10 min read
Java Program to Check horizontal and vertical symmetry in binary matrix
Given a 2D binary matrix of N rows and M columns. The task is to check whether the matrix is horizontally symmetric, vertically symmetric, or both. The matrix is said to be horizontally symmetric if the first row is the same as the last row, the second row is the same as the second last row, and so on. And the matrix is said to be vertically symmet
4 min read
Article Tags :
Practice Tags :