Related Articles

# Number of lines from given N points not parallel to X or Y axis

• Last Updated : 25 May, 2021

Given N distinct integers points on 2D Plane. The task is to count the number of lines which are formed from given N points and not parallel to X or Y axis
Examples:

Input: points[][] = {{1, 2}, {1, 5}, {1, 15}, {2, 10}}
Output:
Choosen pairs are {(1, 2), (2, 10)}, {(1, 5), (2, 10)}, {(1, 15), (2, 10)}.
Input: points[][] = {{1, 2}, {2, 5}, {3, 15}}
Output:
Choose any pair of points.

Approach:

1. We know that
• Line formed by connecting any two-points will be parallel to X-axis if they have the same Y coordinates
• It will be parallel to Y-axis if they have the same X coordinates.
2. Total number of line segments that can formed from N points = 3. Now we will exclude those line segments which are parallel to the X-axis or the Y-axis.
4. For each X coordinate and Y coordinate, calculate the number of points and exclude those line segments at the end.

Below is the implementation of above approach:

## C++

 // C++ program to find the number// of lines which are formed from// given N points and not parallel// to X or Y axis #include using namespace std; // Function to find the number of lines// which are formed from given N points// and not parallel to X or Y axisint NotParallel(int p[], int n){    // This will store the number of points has    // same x or y coordinates using the map as    // the value of coordinate can be very large    map<int, int> x_axis, y_axis;     for (int i = 0; i < n; i++) {         // Counting frequency of each x and y        // coordinates        x_axis[p[i]]++;        y_axis[p[i]]++;    }     // Total number of pairs can be formed    int total = (n * (n - 1)) / 2;     for (auto i : x_axis) {        int c = i.second;         // We can not choose pairs from these as        // they have same x coordinatethus they        // will result line segment        // parallel to y axis        total -= (c * (c - 1)) / 2;    }     for (auto i : y_axis) {        int c = i.second;         // we can not choose pairs from these as        // they have same y coordinate thus they        // will result line segment        // parallel to x-axis        total -= (c * (c - 1)) / 2;    }     // Return the required answer    return total;} // Driver Codeint main(){     int p[] = { { 1, 2 },                   { 1, 5 },                   { 1, 15 },                   { 2, 10 } };     int n = sizeof(p) / sizeof(p);     // Function call    cout << NotParallel(p, n);     return 0;}

## Java

 // Java program to find the number// of lines which are formed from// given N points and not parallel// to X or Y axisimport java.util.*; class GFG{  // Function to find the number of lines// which are formed from given N points// and not parallel to X or Y axisstatic int NotParallel(int p[][], int n){    // This will store the number of points has    // same x or y coordinates using the map as    // the value of coordinate can be very large    HashMap x_axis = new HashMap();    HashMap y_axis = new HashMap();      for (int i = 0; i < n; i++) {          // Counting frequency of each x and y        // coordinates        if(x_axis.containsKey(p[i]))            x_axis.put(p[i], x_axis.get(p[i])+1);        else            x_axis.put(p[i], 1);        if(y_axis.containsKey(p[i]))            y_axis.put(p[i], y_axis.get(p[i])+1);        else            y_axis.put(p[i], 1);    }      // Total number of pairs can be formed    int total = (n * (n - 1)) / 2;      for (Map.Entry i : x_axis.entrySet()) {        int c = i.getValue();          // We can not choose pairs from these as        // they have same x coordinatethus they        // will result line segment        // parallel to y axis        total -= (c * (c - 1)) / 2;    }      for (Map.Entry i : y_axis.entrySet()) {        int c = i.getValue();          // we can not choose pairs from these as        // they have same y coordinate thus they        // will result line segment        // parallel to x-axis        total -= (c * (c - 1)) / 2;    }      // Return the required answer    return total;}  // Driver Codepublic static void main(String[] args){      int p[][] = { { 1, 2 },                   { 1, 5 },                   { 1, 15 },                   { 2, 10 } };      int n = p.length;      // Function call    System.out.print(NotParallel(p, n));  }} // This code is contributed by PrinciRaj1992

## C#

 // C# program to find the number// of lines which are formed from// given N points and not parallel// to X or Y axisusing System;using System.Collections.Generic; class GFG{   // Function to find the number of lines// which are formed from given N points// and not parallel to X or Y axisstatic int NotParallel(int [,]p, int n){    // This will store the number of points has    // same x or y coordinates using the map as    // the value of coordinate can be very large    Dictionary<int,int> x_axis = new Dictionary<int,int>();    Dictionary<int,int> y_axis = new Dictionary<int,int>();       for (int i = 0; i < n; i++) {           // Counting frequency of each x and y        // coordinates        if(x_axis.ContainsKey(p[i, 0]))            x_axis[p[i, 0]] = x_axis[p[i, 0]] + 1;        else            x_axis.Add(p[i, 0], 1);        if(y_axis.ContainsKey(p[i, 1]))            y_axis[p[i, 1]] = y_axis[p[i, 1]] + 1;        else            y_axis.Add(p[i, 1], 1);    }       // Total number of pairs can be formed    int total = (n * (n - 1)) / 2;       foreach (KeyValuePair<int,int> i in x_axis) {        int c = i.Value;           // We can not choose pairs from these as        // they have same x coordinatethus they        // will result line segment        // parallel to y axis        total -= (c * (c - 1)) / 2;    }       foreach (KeyValuePair<int,int> i in y_axis) {        int c = i.Value;           // we can not choose pairs from these as        // they have same y coordinate thus they        // will result line segment        // parallel to x-axis        total -= (c * (c - 1)) / 2;    }       // Return the required answer    return total;}   // Driver Codepublic static void Main(String[] args){       int [,]p = { { 1, 2 },                   { 1, 5 },                   { 1, 15 },                   { 2, 10 } };       int n = p.GetLength(0);       // Function call    Console.Write(NotParallel(p, n)); }} // This code is contributed by Princi Singh

## Python3

 # Python3 program to find the number# of lines which are formed from# given N points and not parallel# to X or Y axis # Function to find the number of lines# which are formed from given N points# and not parallel to X or Y axisdef NotParallel(p, n) :     # This will store the number of points has    # same x or y coordinates using the map as    # the value of coordinate can be very large    x_axis  = {}; y_axis = {};     for i in range(n) :         # Counting frequency of each x and y        # coordinates        if p[i] not in x_axis :            x_axis[p[i]] = 0;                     x_axis[p[i]] += 1;         if p[i] not in y_axis :            y_axis[p[i]] = 0;                 y_axis[p[i]] += 1;     # Total number of pairs can be formed    total = (n * (n - 1)) // 2;     for i in x_axis :        c =  x_axis[i];         # We can not choose pairs from these as        # they have same x coordinatethus they        # will result line segment        # parallel to y axis        total -= (c * (c - 1)) // 2;     for i in y_axis :        c = y_axis[i];         # we can not choose pairs from these as        # they have same y coordinate thus they        # will result line segment        # parallel to x-axis        total -= (c * (c - 1)) // 2;         # Return the required answer    return total;  # Driver Codeif __name__ == "__main__" :     p = [ [ 1, 2 ],            [1, 5 ],            [1, 15 ],            [ 2, 10 ] ];     n = len(p);     # Function call    print(NotParallel(p, n));     # This code is contributed by AnkitRai01

## Javascript

 
Output:
3

Time Complexity: O(N)

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.

My Personal Notes arrow_drop_up