Skip to content
Related Articles

Related Articles

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

View Discussion
Improve Article
Save Article
  • Last Updated : 24 Nov, 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:
Chosen 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 = \binom{N}{2}= \frac{N*(N-1)}{2}
     
  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 <bits/stdc++.h>
using namespace std;
 
// Function to find the number of lines
// which are formed from given N points
// and not parallel to X or Y axis
int NotParallel(int p[][2], 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][0]]++;
        y_axis[p[i][1]]++;
    }
 
    // 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 Code
int main()
{
 
    int p[][2] = { { 1, 2 },
                   { 1, 5 },
                   { 1, 15 },
                   { 2, 10 } };
 
    int n = sizeof(p) / sizeof(p[0]);
 
    // 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 axis
import 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 axis
static 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<Integer,Integer> x_axis = new HashMap<Integer,Integer>();
    HashMap<Integer,Integer> y_axis = new HashMap<Integer,Integer>();
  
    for (int i = 0; i < n; i++) {
  
        // Counting frequency of each x and y
        // coordinates
        if(x_axis.containsKey(p[i][0]))
            x_axis.put(p[i][0], x_axis.get(p[i][0])+1);
        else
            x_axis.put(p[i][0], 1);
        if(y_axis.containsKey(p[i][1]))
            y_axis.put(p[i][1], y_axis.get(p[i][1])+1);
        else
            y_axis.put(p[i][1], 1);
    }
  
    // Total number of pairs can be formed
    int total = (n * (n - 1)) / 2;
  
    for (Map.Entry<Integer,Integer> 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<Integer,Integer> 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 Code
public 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 axis
using 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 axis
static 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 Code
public 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 axis
def 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][0] not in x_axis :
            x_axis[p[i][0]] = 0;
             
        x_axis[p[i][0]] += 1;
 
        if p[i][1] not in y_axis :
            y_axis[p[i][1]] = 0;
         
        y_axis[p[i][1]] += 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 Code
if __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




<script>
 
// Javascript 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 axis
function 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
    var x_axis = new Map(), y_axis = new Map();
 
    for (var i = 0; i < n; i++) {
 
        // Counting frequency of each x and y
        // coordinates
        if(x_axis.has(p[i][0]))
            x_axis.set(p[i][0], x_axis.get(p[i][0])+1)
        else
            x_axis.set(p[i][0], 1)
         
        if(y_axis.has(p[i][1]))
            y_axis.set(p[i][1], y_axis.get(p[i][1])+1)
        else
            y_axis.set(p[i][1], 1)
    }
 
    // Total number of pairs can be formed
    var total = (n * (n - 1)) / 2;
 
    x_axis.forEach((value, key) => {
         
        var c = 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;
    });
 
    y_axis.forEach((value, key) => {
         
        var c = 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 Code
var p = [ [ 1, 2 ],
               [ 1, 5 ],
               [ 1, 15 ],
               [ 2, 10 ] ];
var n = p.length;
 
// Function call
document.write( NotParallel(p, n));
 
// This code is contributed by itsok.
</script>

Output: 

3

 

Time Complexity: O(N)

Auxiliary Space: O(N)
 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!