# Count of Right-Angled Triangle formed from given N points whose base or perpendicular are parallel to X or Y axis

• Difficulty Level : Medium
• Last Updated : 09 Jun, 2021

Given an array arr[] of N distinct integers points on the 2D Plane. The task is to count the number of Right-Angled Triangle from N points such that the base or perpendicular is parallel to the X or Y-axis.

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr[][] = {{4, 2}, {2, 1}, {1, 3}}
Output:
Explanation: In the above image there is no right-angled triangle formed.
Input: arr[][] = {{1, 2}, {2, 1}, {2, 2}, {2, 3}, {3, 2}}
Output:
Explanation: In the above image there are 4 right-angled triangles formed by triangles ACB, ACD, DCE, BCE.

Approach: The idea is to store the count of each co-ordinate’s having the same X and Y co-ordinates respectively. Now traverse each given points and the count of a right-angled triangle formed by each coordinate (X, Y) is given by:

Count of right-angled triangles = (frequencies of X coordinates – 1) * (frequencies of Y coordinates – 1)

Below are the steps:

• Create two maps to store the count of points, one for having the same X-coordinate and another for having the same Y-coordinate.
• For each value in the map of x-coordinate and in the map of y-coordinate choose that pair of points as pivot elements and find the frequency of that pivot element.
• For each pivot element(say pivot) in the above step, the count of right-angled is given by:

(m1[pivot].second-1)*(m2[pivot].second-1)

• Similarly, calculate the total possible right-angled triangle for other N points given.
• Finally, sum all the possible triangle obtained that is the final answer.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to find the number of right``// angled triangle that are formed from``// given N points whose perpendicular or``// base is parallel to X or Y axis``int` `RightAngled(``int` `a[], ``int` `n)``{` `    ``// To store the number of points``    ``// has same x or y coordinates``    ``unordered_map<``int``, ``int``> xpoints;``    ``unordered_map<``int``, ``int``> ypoints;` `    ``for` `(``int` `i = 0; i < n; i++) {``        ``xpoints[a[i]]++;``        ``ypoints[a[i]]++;``    ``}` `    ``// Store the total count of triangle``    ``int` `count = 0;` `    ``// Iterate to check for total number``    ``// of possible triangle``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``if` `(xpoints[a[i]] >= 1``            ``&& ypoints[a[i]] >= 1) {` `            ``// Add the count of triangles``            ``// formed``            ``count += (xpoints[a[i]] - 1)``                     ``* (ypoints[a[i]] - 1);``        ``}``    ``}` `    ``// Total possible triangle``    ``return` `count;``}` `// Driver Code``int` `main()``{``    ``int` `N = 5;` `    ``// Given N points``    ``int` `arr[] = { { 1, 2 }, { 2, 1 },``                     ``{ 2, 2 }, { 2, 3 },``                     ``{ 3, 2 } };` `    ``// Function Call``    ``cout << RightAngled(arr, N);` `    ``return` `0;``}`

## Python3

 `# Python3 program for the above approach``from` `collections ``import` `defaultdict` `# Function to find the number of right``# angled triangle that are formed from``# given N points whose perpendicular or``# base is parallel to X or Y axis``def` `RightAngled(a, n):``    ` `    ``# To store the number of points``    ``# has same x or y coordinates``    ``xpoints ``=` `defaultdict(``lambda``:``0``)``    ``ypoints ``=` `defaultdict(``lambda``:``0``)``    ` `    ``for` `i ``in` `range``(n):``        ``xpoints[a[i][``0``]] ``+``=` `1``        ``ypoints[a[i][``1``]] ``+``=` `1``        ` `    ``# Store the total count of triangle``    ``count ``=` `0``    ` `    ``# Iterate to check for total number``    ``# of possible triangle``    ``for` `i ``in` `range``(n):``        ``if` `(xpoints[a[i][``0``]] >``=` `1` `and``            ``ypoints[a[i][``1``]] >``=` `1``):``            ` `            ``# Add the count of triangles``            ``# formed``            ``count ``+``=` `((xpoints[a[i][``0``]] ``-` `1``) ``*``                      ``(ypoints[a[i][``1``]] ``-` `1``))``            ` `    ``# Total possible triangle``    ``return` `count` `# Driver Code``N ``=` `5` `# Given N points``arr ``=` `[ [ ``1``, ``2` `], [ ``2``, ``1` `],``        ``[ ``2``, ``2` `], [ ``2``, ``3` `],``        ``[ ``3``, ``2` `] ]` `# Function call``print``(RightAngled(arr, N))` `# This code is contributed by Stuti Pathak`

## Java

 `// Java program for the above approach``import` `java.util.*;``class` `GFG{` `// Function to find the number of right``// angled triangle that are formed from``// given N points whose perpendicular or``// base is parallel to X or Y axis``static` `int` `RightAngled(``int` `a[][], ``int` `n)``{` `    ``// To store the number of points``    ``// has same x or y coordinates``    ``HashMap xpoints  = ``new` `HashMap();``    ``HashMap ypoints  = ``new` `HashMap();` `    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{``        ``if``(xpoints.containsKey(a[i][``0``]))``        ``{``            ``xpoints.put(a[i][``0``], xpoints.get(a[i][``0``]) + ``1``);``        ``}``        ``else``        ``{``            ``xpoints.put(a[i][``0``], ``1``);``        ``}``        ``if``(ypoints.containsKey(a[i][``1``]))``        ``{``            ``ypoints.put(a[i][``1``], ypoints.get(a[i][``1``]) + ``1``);``        ``}``        ``else``        ``{``            ``ypoints.put(a[i][``1``], ``1``);``        ``}``    ``}` `    ``// Store the total count of triangle``    ``int` `count = ``0``;` `    ``// Iterate to check for total number``    ``// of possible triangle``    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{``        ``if` `(xpoints.get(a[i][``0``]) >= ``1` `&&``            ``ypoints.get(a[i][``1``]) >= ``1``)``        ``{` `            ``// Add the count of triangles``            ``// formed``            ``count += (xpoints.get(a[i][``0``]) - ``1``) *``                     ``(ypoints.get(a[i][``1``]) - ``1``);``        ``}``    ``}` `    ``// Total possible triangle``    ``return` `count;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `N = ``5``;` `    ``// Given N points``    ``int` `arr[][] = { { ``1``, ``2` `}, { ``2``, ``1` `},``                    ``{ ``2``, ``2` `}, { ``2``, ``3` `},``                    ``{ ``3``, ``2` `} };` `    ``// Function Call``    ``System.out.print(RightAngled(arr, N));``}``}` `// This code is contributed by Rajput-Ji`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;``class` `GFG{` `    ``// Function to find the number of right``    ``// angled triangle that are formed from``    ``// given N points whose perpendicular or``    ``// base is parallel to X or Y axis``    ``static` `int` `RightAngled(``int``[, ] a, ``int` `n)``    ``{` `        ``// To store the number of points``        ``// has same x or y coordinates``        ``Dictionary<``int``, ``int``> xpoints = ``new` `Dictionary<``int``, ``int``>();``        ``Dictionary<``int``, ``int``> ypoints = ``new` `Dictionary<``int``, ``int``>();` `        ``for` `(``int` `i = 0; i < n; i++)``        ``{``            ``if` `(xpoints.ContainsKey(a[i, 0]))``            ``{``                ``xpoints[a[i, 0]] = xpoints[a[i, 0]] + 1;``            ``}``            ``else``            ``{``                ``xpoints.Add(a[i, 0], 1);``            ``}``            ``if` `(ypoints.ContainsKey(a[i, 1]))``            ``{``                ``ypoints[a[i, 1]] = ypoints[a[i, 1]] + 1;``            ``}``            ``else``            ``{``                ``ypoints.Add(a[i, 1], 1);``            ``}``        ``}` `        ``// Store the total count of triangle``        ``int` `count = 0;` `        ``// Iterate to check for total number``        ``// of possible triangle``        ``for` `(``int` `i = 0; i < n; i++)``        ``{``            ``if` `(xpoints[a[i, 0]] >= 1 &&``                ``ypoints[a[i, 1]] >= 1)``            ``{` `                ``// Add the count of triangles``                ``// formed``                ``count += (xpoints[a[i, 0]] - 1) *``                         ``(ypoints[a[i, 1]] - 1);``            ``}``        ``}` `        ``// Total possible triangle``        ``return` `count;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int` `N = 5;` `        ``// Given N points``        ``int``[, ] arr = {{1, 2}, {2, 1},``                       ``{2, 2}, {2, 3}, {3, 2}};` `        ``// Function Call``        ``Console.Write(RightAngled(arr, N));``    ``}``}` `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output:
`4`

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

My Personal Notes arrow_drop_up