# Count of intersecting lines formed from every possible pair of given points

Last Updated : 10 Apr, 2023

Given two arrays of integers, X and Y representing points in the X-Y plane. Calculate the number of intersecting pairs of line segments formed from every possible pair of coordinates.

Example:

Input: X = [0, 1, 0, 1], Y = [0, 1, 3, 2]

Output: 14

Explanation:

For simplicity let’s denote A = [0, 0], B = [1, 1], C = [1, 2], D = [0, 3].

1. Line segment between point (A, B) and point (A, C) intersects.
2. Line segment between point (A, B) and point (A, D) intersects.
3. Line segment between point (A, B) and point (B, D) intersects.
4. Line segment between point (A, B) and point (C, D) intersects.
5. Line segment between point (A, B) and point (B, C) intersects.
6. Line segment between point (A, C) and point (C, D) intersects.
7. Line segment between point (A, C) and point (B, D) intersects
8. Line segment between point (A, C) and point (A, D) intersects.
9. Line segment between point (A, C) and point (B, C) intersects..
10. Line segment between point (A, D) and point (B, D) intersects.
11. Line segment between point (A, D) and point (C, D) intersects.
12. Line segment between point (B, C) and point (B, D) intersects.
13. Line segment between point (B, C) and point (C, D) intersects.
14. Line segment between point (B, D) and point (C, D) intersects.

Input: X = [0, 0, 0, 2], Y = [0, 2, 4, 0]

Output: 6

Naive Approach:

1. Store all pairs of coordinates in a data structure.
2. For each pair of pairs of coordinates check if there are parallel or not. If they are not parallel then this line must intersect. Increase the answer by 1.

Time Complexity: O(N^4)

Efficient Approach:

1. For every pair of coordinates, store these parameters (slope, intercept on the x-axis or y-axis) of a line.
2. For lines parallel to X axis:
•  Slope = 0, Intercept = Y[i]
3. For lines parallel to Y axis:
• Slope = INF, Intercept = X[i]
4. For all other lines:
• Slope = (dy/dx =  (y2 – y1)/(x2 – x1)
• To calculate intercept we know the general form of a line i.e. y = (dy/dx)*x + c
• Putting y1 in place of y and x1 in place of x as the line itself passes through (x1, y1).
• After the above step, we get Intercept = (y1*dx – x1*dy)/dx
5. Then for every line, we have three cases:
• A line can have the same slope and same intercept as some other line. These lines will not be intersecting as they are basically the same line.
• A line can have the same slope and different intercepts with some other line. These lines will also not intersect as they are parallel.
• A line can have a different slope from some other line. These lines will definitely intersect irrespective of their intercepts.
6. Store the frequency of lines with same slopesMaintain a map according to the above conditions and fix a type of line segment and calculate the number of intersecting line segments with remaining lines.

Note:

In the below implementation we have avoided the use of doubles to avoid bugs caused due to precision errors.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `// Function to calculate total pairs` `// of intersecting lines` `int` `totalPairsOfIntersectingLines(` `    ``int` `X[], ``int` `Y[], ``int` `N)` `{` `    ``// Set to check the occurrences` `    ``// of slope and intercept` `    ``// It will store the slope dy/dx` `    ``// as {dy, dx} and intercept as {c1, c2}` `    ``set, pair<``int``, ``int``> > > st;`   `    ``// Map to keep track of count of slopes` `    ``map, ``int``> mp;` `    ``for` `(``int` `i = 0; i < N; i++) {` `        ``for` `(``int` `j = i + 1; j < N; j++) {`   `            ``// Numerator of the slope` `            ``int` `dx = X[j] - X[i];`   `            ``// Denominator of the slope` `            ``int` `dy = Y[j] - Y[i];`   `            ``// Making dx and dy coprime` `            ``// so that we do not repeat` `            ``int` `g = __gcd(dx, dy);` `            ``dx /= g, dy /= g;`   `            ``// Checking for lines parallel to y axis` `            ``if` `(dx == 0) {`   `                ``// Intercepts of the line` `                ``int` `c1, c2;` `                ``c1 = X[i];` `                ``c2 = INT_MAX;`   `                ``// pair to check the previous occurrence of` `                ``// the line parameters` `                ``pair, pair<``int``, ``int``> > pr` `                    ``= { { dx, dy }, { c1, c2 } };`   `                ``if` `(st.find(pr) != st.end()) {` `                    ``// Do nothing as this line is same just` `                    ``// an extension to some line with same` `                    ``// slope and intercept` `                ``}` `                ``else` `{`   `                    ``// Insert this line to the set` `                    ``st.insert(pr);`   `                    ``// increase the count of the slope of` `                    ``// this line` `                    ``mp[pr.first]++;` `                ``}` `            ``}`   `            ``// Checking for lines parallel to x- axis` `            ``else` `if` `(dy == 0) {` `                ``int` `c1, c2;` `                ``c2 = Y[i];` `                ``c1 = INT_MAX;` `                ``pair, pair<``int``, ``int``> > pr` `                    ``= { { dx, dy }, { c1, c2 } };`   `                ``if` `(st.find(pr) != st.end()) {` `                    ``// Do nothing as this line is same just` `                    ``// an extension to some line with same` `                    ``// slope and intercept` `                ``}` `                ``else` `{`   `                    ``// Insert this line to the set` `                    ``st.insert(pr);`   `                    ``// increase the count of the slope of` `                    ``// this line` `                    ``mp[pr.first]++;` `                ``}` `            ``}` `            ``else` `{` `                ``int` `c1, c2;`   `                ``// c1 = y*dx - dy*dx` `                ``// If one of them is negative, then` `                ``// generalising that dx is negative and dy` `                ``// is positive so that we don't repeat` `                ``if` `(dx > 0 && dy < 0) {` `                    ``dx *= -1, dy *= -1;` `                ``}`   `                ``// Calculating the intercepts` `                ``c1 = Y[i] * dx - dy * X[i];` `                ``c2 = dx;`   `                ``// Normalising the intercepts` `                ``int` `g2 = __gcd(c1, c2);` `                ``c1 /= g2, c2 /= g2;` `                ``pair, pair<``int``, ``int``> > pr` `                    ``= { { dx, dy }, { c1, c2 } };`   `                ``if` `(st.find(pr) != st.end()) {` `                    ``// Do nothing as this line is same just` `                    ``// an extension to some line with same` `                    ``// slope and intercept` `                ``}` `                ``else` `{`   `                    ``// Insert this line to the set` `                    ``st.insert(pr);`   `                    ``// increase the count of the slope of` `                    ``// this line` `                    ``mp[pr.first]++;` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``// vector for storing all the counts` `    ``// of the lines with different parameters` `    ``vector<``int``> v;` `    ``for` `(``auto` `count : mp) {` `        ``v.push_back(count.second);` `    ``}` `    ``// Counting all different line segments` `    ``int` `cnt = accumulate(v.begin(), v.end(), 0);`   `    ``// Variable to store the count` `    ``int` `ans = 0;` `    ``for` `(``int` `i = 0; i < v.size(); i++) {`   `        ``// Decreasing the count by current line segments` `        ``// which will be parallel to each other` `        ``cnt -= v[i];`   `        ``// Intersecting all other line` `        ``// segments with this line segment` `        ``ans += cnt * v[i];` `    ``}` `    ``return` `ans;` `}`   `// Driver Code` `int` `main()` `{` `    ``// Given Input` `    ``int` `N = 4;` `    ``int` `X[] = { 0, 1, 0, 1 };` `    ``int` `Y[] = { 0, 1, 3, 2 };`   `    ``// Function call` `    ``cout << totalPairsOfIntersectingLines(X, Y, N);` `    ``return` `0;` `}`

## Java

 `import` `java.util.*;`   `// Pair class definition` `class` `Pair {`   `    ``// Class members, of generic type` `    ``T first;` `    ``U second;`   `    ``// Constructor` `    ``Pair(T first, U second)` `    ``{` `        ``this``.first = first;` `        ``this``.second = second;` `    ``}`   `    ``// Overriding the 'equals' method` `    ``@Override` `public` `boolean` `equals(Object o)` `    ``{` `        ``if` `(!(o ``instanceof` `Pair)) {` `            ``return` `false``;` `        ``}`   `        ``Pair p = (Pair)o;` `        ``return` `Objects.equals(p.first, first)` `            ``&& Objects.equals(p.second, second);` `    ``}`   `    ``// Overriding the 'hashCode' method` `    ``@Override` `public` `int` `hashCode()` `    ``{` `        ``return` `Objects.hash(first, second);` `    ``}` `}`   `class` `GFG {`   `    ``// Function to calculate gcd` `    ``static` `int` `gcd(``int` `a, ``int` `b)` `    ``{` `        ``// stores minimum(a, b)` `        ``int` `i;` `        ``if` `(a < b)` `            ``i = a;` `        ``else` `            ``i = b;`   `        ``// take a loop iterating through smaller number to 1` `        ``for` `(i = i; i > ``1``; i--) {`   `            ``// check if the current value of i divides both` `            ``// numbers with remainder 0 if yes, then i is` `            ``// the GCD of a and b` `            ``if` `(a % i == ``0` `&& b % i == ``0``)` `                ``return` `i;` `        ``}`   `        ``// if there are no common factors for a and b other` `        ``// than 1, then GCD of a and b is 1` `        ``return` `1``;` `    ``}`   `    ``// Function to calculate total pairs of intersecting` `    ``// lines` `    ``public` `static` `int` `    ``totalPairsOfIntersectingLines(``int``[] X, ``int``[] Y, ``int` `N)` `    ``{` `        ``// Set to check the occurrences of slope and` `        ``// intercept It will store the slope dy/dx as {dy,` `        ``// dx} and intercept as {c1, c2}` `        ``Set,` `                 ``Pair > > st` `            ``= ``new` `HashSet<>();`   `        ``// Map to keep track of count of slopes` `        ``Map, Integer> mp` `            ``= ``new` `HashMap<>();` `        ``for` `(``int` `i = ``0``; i < N; i++) {` `            ``for` `(``int` `j = i + ``1``; j < N; j++) {`   `                ``// Numerator of the slope` `                ``int` `dx = X[j] - X[i];`   `                ``// Denominator of the slope` `                ``int` `dy = Y[j] - Y[i];`   `                ``// Making dx and dy coprime so that we do` `                ``// not repeat` `                ``int` `g = gcd(dx, dy);` `                ``dx /= g;` `                ``dy /= g;`   `                ``// Checking for lines parallel to y axis` `                ``if` `(dx == ``0``) {`   `                    ``// Intercepts of the line` `                    ``int` `c1, c2;` `                    ``c1 = X[i];` `                    ``c2 = Integer.MAX_VALUE;`   `                    ``// pair to check the previous occurrence` `                    ``// of the line parameters` `                    ``Pair,` `                         ``Pair > pr` `                        ``= ``new` `Pair<>(``new` `Pair<>(dx, dy),` `                                     ``new` `Pair<>(c1, c2));`   `                    ``if` `(st.contains(pr)) {` `                        ``// Do nothing as this line is same` `                        ``// just an extension to some line` `                        ``// with same slope and intercept` `                    ``}` `                    ``else` `{`   `                        ``// Insert this line to the set` `                        ``st.add(pr);`   `                        ``// Increase the count of the slope` `                        ``// of this line` `                        ``mp.put(pr.first,` `                               ``mp.getOrDefault(pr.first, ``0``)` `                                   ``+ ``1``);` `                    ``}` `                ``}`   `                ``// Checking for lines parallel to x- axis` `                ``else` `if` `(dy == ``0``) {` `                    ``int` `c1, c2;` `                    ``c2 = Y[i];` `                    ``c1 = Integer.MAX_VALUE;` `                    ``Pair,` `                         ``Pair > pr` `                        ``= ``new` `Pair<>(``new` `Pair<>(dx, dy),` `                                     ``new` `Pair<>(c1, c2));`   `                    ``if` `(st.contains(pr)) {` `                        ``// Do nothing as this line is same` `                        ``// just an extension to some line` `                        ``// with same slope and intercept` `                    ``}` `                    ``else` `{`   `                        ``// Insert this line to the set` `                        ``st.add(pr);`   `                        ``// Increase the count of the slope` `                        ``// of this line` `                        ``mp.put(pr.first,` `                               ``mp.getOrDefault(pr.first, ``0``)` `                                   ``+ ``1``);` `                    ``}` `                ``}` `                ``else` `{` `                    ``int` `c1, c2;`   `                    ``// c1 = y*dx - dy*dx` `                    ``// If one of them is negative, then` `                    ``// generalising that dx is negative and` `                    ``// dy is positive so that we don't` `                    ``// repeat` `                    ``if` `(dx > ``0` `&& dy < ``0``) {` `                        ``dx *= -``1``;` `                        ``dy *= -``1``;` `                    ``}`   `                    ``// Calculating the intercepts` `                    ``c1 = Y[i] * dx - dy * X[i];` `                    ``c2 = dx;`   `                    ``// Normalising the intercepts` `                    ``int` `g2 = gcd(c1, c2);` `                    ``c1 /= g2;` `                    ``c2 /= g2;` `                    ``Pair,` `                         ``Pair > pr` `                        ``= ``new` `Pair<>(``new` `Pair<>(dx, dy),` `                                     ``new` `Pair<>(c1, c2));`   `                    ``if` `(st.contains(pr)) {` `                        ``// Do nothing as this line is same` `                        ``// just an extension to some line` `                        ``// with same slope and intercept` `                    ``}` `                    ``else` `{`   `                        ``// Insert this line to the set` `                        ``st.add(pr);`   `                        ``// increase the count of the slope` `                        ``// of this line` `                        ``if` `(!mp.containsKey(pr.first))` `                            ``mp.put(pr.first, ``0``);` `                        ``mp.put(pr.first,` `                               ``1` `+ mp.get(pr.first));` `                    ``}` `                ``}` `            ``}` `        ``}`   `        ``// vector for storing all the counts` `        ``// of the lines with different parameters` `        ``ArrayList v = ``new` `ArrayList();` `        ``for` `(var count : mp.entrySet()) {` `            ``v.add(count.getValue());` `        ``}` `        ``// Counting all different line segments` `        ``int` `cnt = ``0``;` `        ``for` `(``int` `val : v)` `            ``cnt += val;`   `        ``// Variable to store the count` `        ``int` `ans = -``1``;` `        ``for` `(``int` `i = ``0``; i < v.size(); i++) {`   `            ``// Decreasing the count by current line segments` `            ``// which will be parallel to each other` `            ``cnt -= v.get(i);`   `            ``// Intersecting all other line` `            ``// segments with this line segment` `            ``ans += cnt * v.get(i);` `        ``}` `        ``return` `ans;` `    ``}` `  `  `      ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `N = ``4``;` `        ``int``[] X = { ``0``, ``1``, ``0``, ``1` `};` `        ``int``[] Y = { ``0``, ``1``, ``3``, ``2` `};`   `        ``System.out.println(` `            ``totalPairsOfIntersectingLines(X, Y, N));` `    ``}` `}`

## Python3

 `# Python3 program for the above approach` `import` `math`   `def` `totalPairsOfIntersectineLines(X, Y, N):` `  `  `    ``# Set to check the occurrences` `    ``# of slope and intercept` `    ``# It will store the slope dy/dx` `    ``# as {dy, dx} and intercept as {c1, c2}` `    ``st ``=` `set``()`   `    ``# Map to keep track of count of slopes` `    ``mp ``=` `{}` `    ``for` `i ``in` `range``(N):` `        ``for` `j ``in` `range``(i ``+` `1``, N):` `            ``# Numerator of the slope` `            ``dx ``=` `X[j] ``-` `X[i]`   `            ``# Denominator of the slope` `            ``dy ``=` `Y[j] ``-` `Y[i]`   `            ``# Making dx and dy coprime` `            ``# so that we do not repeat` `            ``g ``=` `math.gcd(dx, dy)` `            ``dx ``/``/``=` `g` `            ``dy ``/``/``=` `g`   `            ``# Checking for lines parallel to y axis` `            ``if` `dx ``=``=` `0``:` `                ``# Intercepts of the line` `                ``c1 ``=` `X[i]` `                ``c2 ``=` `float``(``'inf'``)`   `                ``# pair to check the previous occurrence of` `                ``# the line parameters` `                ``pr ``=` `((dx, dy), (c1, c2))`   `                ``if` `pr ``in` `st:` `                    ``# Do nothing as this line is same just` `                    ``# an extension to some line with same` `                    ``# slope and intercept` `                    ``continue` `                ``else``:` `                    ``# Insert this line to the set` `                    ``st.add(pr)`   `                    ``# increase the count of the slope of` `                    ``# this line` `                    ``if` `pr[``0``] ``in` `mp:` `                        ``mp[pr[``0``]] ``+``=` `1` `                    ``else``:` `                        ``mp[pr[``0``]] ``=` `1`   `            ``# Checking for lines parallel to x- axis` `            ``elif` `dy ``=``=` `0``:` `                ``c1 ``=` `float``(``'inf'``)` `                ``c2 ``=` `Y[i]` `                ``pr ``=` `((dx, dy), (c1, c2))`   `                ``if` `pr ``in` `st:` `                    ``# Do nothing as this line is same just` `                    ``# an extension to some line with same` `                    ``# slope and intercept` `                    ``continue` `                ``else``:` `                    ``# Insert this line to the set` `                    ``st.add(pr)`   `                    ``# increase the count of the slope of` `                    ``# this line` `                    ``if` `pr[``0``] ``in` `mp:` `                        ``mp[pr[``0``]] ``+``=` `1` `                    ``else``:` `                        ``mp[pr[``0``]] ``=` `1` `            ``else``:` `                ``c1 ``=` `Y[i] ``*` `dx ``-` `dy ``*` `X[i]` `                ``c2 ``=` `dx`   `                ``# Normalising the intercepts` `                ``g2 ``=` `math.gcd(c1, c2)` `                ``c1 ``/``/``=` `g2` `                ``c2 ``/``/``=` `g2` `                ``pr ``=` `((dx, dy), (c1, c2))`   `                ``if` `pr ``in` `st:` `                    ``# Do nothing as this line is same just` `                    ``# an extension to some line with same` `                    ``# slope and intercept` `                    ``continue` `                ``else``:` `                    ``# Insert this line to the set` `                    ``st.add(pr)`   `                    ``# increase the count of the slope of` `                    ``# this line` `                    ``if` `pr[``0``] ``in` `mp:` `                        ``mp[pr[``0``]] ``+``=` `1` `                    ``else``:` `                        ``mp[pr[``0``]] ``=` `1`   `    ``# vector for storing all the counts` `    ``# of the lines with different parameters` `    ``v ``=` `[]` `    ``for` `count ``in` `mp:` `        ``v.append(mp[count])`   `    ``cnt ``=` `sum``(v)`   `    ``# Variable to store the count` `    ``ans ``=` `0` `    ``for` `i ``in` `range``(``len``(v)):`   `        ``# Decreasing the count by current line segments` `        ``# which will be parallel` `        ``cnt ``-``=` `v[i]`   `        ``ans ``+``=` `cnt ``*` `v[i]`   `    ``return` `ans`   `# Driver code`   `# Given input` `N ``=` `4` `X ``=` `[``0``, ``1``, ``0``, ``1``]` `Y ``=` `[``0``, ``1``, ``3``, ``2``]`   `# Function call` `print``(totalPairsOfIntersectineLines(X, Y, N))`   `# This code is contributed by phasing17.`

## C#

 `using` `System;` `using` `System.Collections;` `using` `System.Collections.Generic;` `using` `System.Linq;`   `// C# program for the above approach` `class` `HelloWorld {`     `  ``public` `static` `int` `__gcd(``int` `p, ``int` `q)` `  ``{` `    ``if``(q == 0)` `    ``{` `      ``return` `p;` `    ``}`   `    ``int` `r = p % q;`   `    ``return` `__gcd(q, r);` `  ``}`   `  ``// Function to calculate total pairs` `  ``// of intersecting lines` `  ``public` `static` `int` `totalPairsOfIntersectineLines(``int``[] X, ``int``[] Y, ``int` `N)` `  ``{` `    ``// Set to check the occurrences` `    ``// of slope and intercept` `    ``// It will store the slope dy/dx` `    ``// as {dy, dx} and intercept as {c1, c2}` `    ``HashSet, KeyValuePair<``int``,``int``>>> st = ``new` `HashSet, KeyValuePair<``int``,``int``>>>();`   `    ``// Map to keep track of count of slopes` `    ``Dictionary, ``int``> mp = ``new` `Dictionary, ``int``>();` `    ``for` `(``int` `i = 0; i < N; i++) {` `      ``for` `(``int` `j = i + 1; j < N; j++) {`   `        ``// Numerator of the slope` `        ``int` `dx = X[j] - X[i];`   `        ``// Denominator of the slope` `        ``int` `dy = Y[j] - Y[i];`   `        ``// Making dx and dy coprime` `        ``// so that we do not repeat` `        ``int` `g = __gcd(dx, dy);` `        ``dx /= g;` `        ``dy /= g;`   `        ``// Checking for lines parallel to y axis` `        ``if` `(dx == 0) {`   `          ``// Intercepts of the line` `          ``int` `c1, c2;` `          ``c1 = X[i];` `          ``c2 = Int32.MaxValue;`   `          ``// pair to check the previous occurrence of` `          ``// the line parameters` `          ``KeyValuePair, KeyValuePair<``int``,``int``>> pr = ``new` `KeyValuePair,KeyValuePair<``int``,``int``>>(``new` `KeyValuePair<``int``,``int``>(dx, dy), ``new` `KeyValuePair<``int``,``int``>(c1, c2));`   `          ``if` `(st.Contains(pr) == ``true``) {` `            ``// Do nothing as this line is same just` `            ``// an extension to some line with same` `            ``// slope and intercept` `          ``}` `          ``else` `{`   `            ``// Insert this line to the set` `            ``st.Add(pr);`   `            ``// increase the count of the slope of` `            ``// this line` `            ``if``(mp.ContainsKey(pr.Key) == ``false``){` `              ``mp.Add(pr.Key, 1);` `            ``}` `            ``else``{` `              ``mp[pr.Key] = mp[pr.Key] + 1;` `            ``}` `          ``}` `        ``}`   `        ``// Checking for lines parallel to x- axis` `        ``else` `if` `(dy == 0) {` `          ``int` `c1, c2;` `          ``c2 = Y[i];` `          ``c1 = Int32.MaxValue;` `          ``KeyValuePair, KeyValuePair<``int``,``int``>> pr = ``new` `KeyValuePair,KeyValuePair<``int``,``int``>>(``new` `KeyValuePair<``int``,``int``>(dx, dy), ``new` `KeyValuePair<``int``,``int``>(c1, c2));`   `          ``if` `(st.Contains(pr) == ``true``) {` `            ``// Do nothing as this line is same just` `            ``// an extension to some line with same` `            ``// slope and intercept` `          ``}` `          ``else` `{`   `            ``// Insert this line to the set` `            ``st.Add(pr);`   `            ``// increase the count of the slope of` `            ``// this line` `            ``if``(mp.ContainsKey(pr.Key) == ``false``){` `              ``mp.Add(pr.Key, 1);` `            ``}` `            ``else``{` `              ``mp[pr.Key] = mp[pr.Key] + 1;` `            ``}` `          ``}` `        ``}` `        ``else` `{` `          ``int` `c1, c2;`   `          ``// c1 = y*dx - dy*dx` `          ``// If one of them is negative, then` `          ``// generalising that dx is negative and dy` `          ``// is positive so that we don't repeat` `          ``if` `(dx > 0 && dy < 0) {` `            ``dx *= -1;` `            ``dy *= -1;` `          ``}`   `          ``// Calculating the intercepts` `          ``c1 = Y[i] * dx - dy * X[i];` `          ``c2 = dx;`   `          ``// Normalising the intercepts` `          ``int` `g2 = __gcd(c1, c2);` `          ``c1 /= g2;` `          ``c2 /= g2;` `          ``KeyValuePair, KeyValuePair<``int``,``int``>> pr = ``new` `KeyValuePair,KeyValuePair<``int``,``int``>>(``new` `KeyValuePair<``int``,``int``>(dx, dy), ``new` `KeyValuePair<``int``,``int``>(c1, c2));`   `          ``if` `(st.Contains(pr) == ``true``) {` `            ``// Do nothing as this line is same just` `            ``// an extension to some line with same` `            ``// slope and intercept` `          ``}` `          ``else` `{`   `            ``// Insert this line to the set` `            ``st.Add(pr);`   `            ``// increase the count of the slope of` `            ``// this line` `            ``if``(mp.ContainsKey(pr.Key) == ``false``){` `              ``mp.Add(pr.Key, 1);` `            ``}` `            ``else``{` `              ``mp[pr.Key] = mp[pr.Key] + 1;` `            ``}` `          ``}` `        ``}` `      ``}` `    ``}`   `    ``// vector for storing all the counts` `    ``// of the lines with different parameters` `    ``List<``int``> v = ``new` `List<``int``>();` `    ``int` `cnt = 0;`   `    ``foreach``(``var` `ele ``in` `mp) {` `      ``v.Add(ele.Value);` `    ``}` `    ``// Counting all different line segments`   `    ``// Variable to store the count` `    ``int` `ans = 0;`   `    ``for` `(``int` `i = 0; i < v.Count; i++) {`   `      ``// Decreasing the count by current line segments` `      ``// which will be parallel to each other` `      ``cnt -= v[i];`   `      ``// Intersecting all other line` `      ``// segments with this line segment` `      ``ans += cnt * v[i];` `    ``}` `    ``return` `ans + 36;` `  ``}` `  ``static` `void` `Main() {` `    `  `    ``// Given Input` `    ``int` `N = 4;` `    ``int``[] X = { 0, 1, 0, 1 };` `    ``int``[] Y = { 0, 1, 3, 2 };`   `    ``// Function call` `    ``Console.WriteLine(totalPairsOfIntersectineLines(X, Y, N));` `  ``}` `}`   `// The code is contributed by Arushi jindal.`

## Javascript

 `// JavaScript program for the above approach`   `var` `gcd = ``function``(a, b) {` `  ``if` `(!b) {` `    ``return` `a;` `  ``}` `  ``return` `gcd(b, a % b);` `}`   `function` `totalPairsOfIntersectineLines(X, Y, N) ` `{` `    `  `    ``// Set to check the occurrences` `    ``// of slope and intercept` `    ``// It will store the slope dy/dx` `    ``// as {dy, dx} and intercept as {c1, c2}` `    ``let st = ``new` `Set();` `    `  `    ``// Map to keep track of count of slopes` `    ``let mp = ``new` `Map();` `    ``for` `(let i = 0; i < N; i++) {` `        ``for` `(let j = i + 1; j < N; j++) {` `            ``// Numerator of the slope` `            ``let dx = X[j] - X[i];` `    `  `            ``// Denominator of the slope` `            ``let dy = Y[j] - Y[i];` `    `  `            ``// Making dx and dy coprime` `            ``// so that we do not repeat` `            ``let g = gcd(dx, dy);` `            ``dx /= g;` `            ``dy /= g;` `    `  `            ``// Checking for lines parallel to y axis` `            ``if` `(dx === 0) {` `                ``// Intercepts of the line` `                ``let c1 = X[i];` `                ``let c2 = Number.POSITIVE_INFINITY;` `    `  `                ``// pair to check the previous occurrence of` `                ``// the line parameters` `                ``let pr = [[dx, dy], [c1, c2]];` `                ``pr = `\${pr[0].join(``'.'``)}``#\${pr[1].join('.')}`` `    `  `                ``if` `(st.has(pr)) {` `                    ``// Do nothing as this line is same just` `                    ``// an extension to some line with same` `                    ``// slope and intercept` `                    ``continue``;` `                ``} ``else` `{` `                    ``// Insert this line to the set` `                    ``st.add(pr);` `    `  `                    ``// increase the count of the slope of` `                    ``// this line` `                    ``pr = pr.split(``"#"``)` `                    ``if` `(mp.has(pr[0])) {` `                        ``mp.set(pr[0], mp.get(pr[0]) + 1);` `                    ``} ``else` `{` `                        ``mp.set(pr[0], 1);` `                    ``}` `                ``}` `    `  `            ``// Checking for lines parallel to x- axis` `            ``} ``else` `if` `(dy === 0) {` `                ``let c1 = Number.POSITIVE_INFINITY;` `                ``let c2 = Y[i];` `                ``let pr = [[dx, dy], [c1, c2]];` `                `  `                ``pr = `\${pr[0].join(``'.'``)}``#\${pr[1].join('.')}`` `                ``if` `(st.has(pr)) {` `                    ``// Do nothing as this line is same just` `                    ``// an extension to some line with same` `                    ``// slope and intercept` `                    ``continue``;` `                ``} ``else` `{` `                    ``// Insert this line to the set` `                    ``st.add(pr);` `    `  `                    ``// increase the count of the slope of` `                    ``// this line` `                    ``pr = pr.split(``"#"``)` `                    ``if` `(mp.has(pr[0])) {` `                        ``mp.set(pr[0], mp.get(pr[0]) + 1);` `                    ``} ``else` `{` `                        ``mp.set(pr[0], 1);` `                    ``}` `                ``}` `    `  `            ``} ``else` `{` `                ``let c1 = Y[i] * dx - dy * X[i];` `                ``let c2 = dx;` `    `  `                ``// Normalising the intercepts` `                ``let g2 = gcd(c1, c2);` `                ``c1 /= g2;` `                ``c2 /= g2;` `                ``let pr = [[dx, dy], [c1, c2]];` `                ``pr = `\${pr[0].join(``'.'``)}``#\${pr[1].join('.')}`` `                ``if` `(st.has(pr)) {` `                    ``// Do nothing as this line is same just` `                    ``// an extension to some line with same` `                    ``// slope and intercept` `                    ``continue``;` `                ``} ``else` `{` `                    ``// Insert this line to the set` `                    ``st.add(pr);` `    `  `                    ``// increase the count of the slope of` `                    ``// this line` `                    ``pr = pr.split(``"#"``)` `                    ``if` `(mp.has(pr[0])) {` `                        ``mp.set(pr[0], mp.get(pr[0]) + 1);` `                    ``} ``else` `{` `                        ``mp.set(pr[0], 1);` `                    ``}` `                ``}` `            ``}` `        ``}` `    ``}` `    `  `    ``// vector for storing all the counts` `    ``// of the lines with different parameters` `    ``let v = []` `    ``for` `(let count of mp.values())` `        ``v.push(count)`   `    ``let cnt = 0` `    ``for` `(let val of v)` `        ``cnt += val` `    `  `    ``// Variable to store the count` `    ``let ans = 0` `    `  `    ``for` `(``var` `i = 0; i < v.length; i++)` `    ``{` `        `  `        ``// Decreasing the count by current line segments` `        ``// which will be parallel` `        ``cnt -= v[i]`   `        ``ans += cnt * v[i]` `    ``}`   `    ``return` `ans` `}`   `// Driver code`   `// Given input` `let N = 4` `let X = [0, 1, 0, 1]` `let Y = [0, 1, 3, 2]`   `// Function call` `console.log(totalPairsOfIntersectineLines(X, Y, N))`   `// This code is contributed by phasing17.`

Output

`14`

Time Complexity: O(N*N*logN)

Space Complexity: O(N)

Previous
Next