Related Articles
Counting cross lines in an array
• Difficulty Level : Hard
• Last Updated : 27 Apr, 2021

Given an unsorted array of distinct elements. Task is to count number of cross lines formed in an array elements after sorting the array elements.
Note: Draw a line between same array elements before sorting and after sorting the array elements.
Examples :

```Input :  arr[] = { 3, 2, 1, 4, 5 }
Output : 3
before sort: 3  2  1  4  5
\ | /   |  |
\|/    |  |
/ | \   |  |
After sort : 1  2  3  4  5
line (1 to 1) cross line (2 to 2)
line (1 to 1) cross line (3 to 3)
line (2 to 2) cross line (3 to 3)
Note: the line between two 4s and the line
between two 5s don't cross any other lines;

Input : arr[] = { 5, 4, 3, 1 }
Output : 6```

Simple solution of this problem is based on the insertion sort. we simply pick each array elements one-by-one and try to find it’s proper position in the sorted array.during finding it’s appropriate position of an element we have to cross all the element_line whose value is greater than current element.
Below is the implementation of above idea :

C++

 `// c++ program to count cross line in array``#include ``using` `namespace` `std;` `// function return count of cross line in an array``int` `countCrossLine(``int` `arr[], ``int` `n)``{``    ``int` `count_crossline = 0;``    ``int` `i, key, j;``    ``for` `(i = 1; i < n; i++) {``        ``key = arr[i];``        ``j = i - 1;` `        ``/* Move elements of arr[0..i-1], that are``          ``greater than key, to one position ahead``          ``of their current position */``        ``while` `(j >= 0 && arr[j] > key) {``            ``arr[j + 1] = arr[j];``            ``j = j - 1;` `            ``// increment cross line by one``            ``count_crossline++;``        ``}``        ``arr[j + 1] = key;``    ``}``    ``return` `count_crossline;``}` `// driver program to test above function``int` `main()``{``    ``int` `arr[] = { 4, 3, 1, 2 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``cout << countCrossLine(arr, n) << endl;``    ``return` `0;``}`

Java

 `// Java program to count``// cross line in array` `class` `GFG``{``    ``static` `int` `countCrossLine(``int` `arr[],``                              ``int` `n)``    ``{``        ``int` `count_crossline = ``0``;``        ``int` `i, key, j;``        ``for` `(i = ``1``; i < n; i++)``        ``{``            ``key = arr[i];``            ``j = i - ``1``;``    ` `            ``// Move elements of arr[0..i-1],``            ``// that are greater than key,``            ``// to one position ahead of``            ``// their current position``            ``while` `(j >= ``0` `&& arr[j] > key)``            ``{``                ``arr[j + ``1``] = arr[j];``                ``j = j - ``1``;``    ` `                ``// increment cross``                ``// line by one``                ``count_crossline++;``            ``}``            ``arr[j + ``1``] = key;``        ``}``        ` `        ``return` `count_crossline;``    ``}``    ` `    ``// Driver Code``    ``public` `static` `void` `main(String args[])``    ``{``        ``int` `arr[] = ``new` `int``[]{ ``4``, ``3``, ``1``, ``2` `};``        ``int` `n = arr.length;``        ``System.out.print(countCrossLine(arr, n));``    ``}``}` `// This code is contributed by Sam007`

Python3

 `# Python3 program to count``# cross line in array``def` `countCrossLine(arr, n):``    ``count_crossline ``=` `0``;``    ``i, key, j ``=` `0``, ``0``, ``0``;``    ``for` `i ``in` `range``(``1``, n):``        ``key ``=` `arr[i];``        ``j ``=` `i ``-` `1``;` `        ``# Move elements of arr[0..i-1],``        ``# that are greater than key,``        ``# to one position ahead of``        ``# their current position``        ``while` `(j >``=` `0` `and` `arr[j] > key):``            ``arr[j ``+` `1``] ``=` `arr[j];``            ``j ``=` `j ``-` `1``;` `            ``# increment cross``            ``# line by one``            ``count_crossline ``+``=` `1``;``        ``arr[j ``+` `1``] ``=` `key;``    ``return` `count_crossline;` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[``4``, ``3``, ``1``, ``2``];``    ``n ``=` `len``(arr);``    ``print``(countCrossLine(arr, n));``    ` `# This code is contributed by PrinciRaj1992`

C#

 `// C# program to count cross line in array``using` `System;` `class` `GFG {` `    ``// function return count of cross line``    ``// in an array``    ``static` `int` `countCrossLine(``int` `[]arr, ``int` `n)``    ``{``        ``int` `count_crossline = 0;``        ``int` `i, key, j;``        ``for` `(i = 1; i < n; i++) {``            ``key = arr[i];``            ``j = i - 1;``    ` `            ``/* Move elements of arr[0..i-1],``            ``that are greater than key, to one``            ``position ahead of their current``            ``position */``            ``while` `(j >= 0 && arr[j] > key) {``                ``arr[j + 1] = arr[j];``                ``j = j - 1;``    ` `                ``// increment cross line by one``                ``count_crossline++;``            ``}``            ``arr[j + 1] = key;``        ``}``        ` `        ``return` `count_crossline;``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``int` `[]arr = ``new` `int``[]{ 4, 3, 1, 2 };``        ``int` `n = arr.Length;``        ``Console.Write(countCrossLine(arr, n));``    ``}``}` `// This code is contributed by Sam007`

PHP

 `= 0 ``and` `\$arr``[``\$j``] > ``\$key``)``        ``{``            ``\$arr``[``\$j` `+ 1] = ``\$arr``[``\$j``];``            ``\$j` `= ``\$j` `- 1;` `            ``// increment cross line by one``            ``\$count_crossline``++;``        ``}``        ``\$arr``[``\$j` `+ 1] = ``\$key``;``    ``}``    ``return` `\$count_crossline``;``}` `    ``// Driver Code``    ``\$arr` `= ``array``( 4, 3, 1, 2 );``    ``\$n` `= ``count``(``\$arr``);``    ``echo` `countCrossLine(``\$arr``, ``\$n``);``    ` `// This code is contributed by anuj_67.``?>`

Javascript

 ``

Output:

`5`

Time complexity: O(n2
Auxiliary space: O(1)
Efficient solution based on the merge sortand inversions count

```   lets we have arr[] { 2, 4, 1, 3 }
\   \ /   /
\  / \ /
/ \  / \
After sort   arr[] { 1, 2, 3, 4 }
and here all inversion are (2, 1), (4, 1), (4, 3)
that mean line 1 : cross line 4, 2
line 2 : cross line 1
line 4 : cross line 3, 1
line 3 : cross line 3
so total unique cross_line are: 3  ```

During mer
Below is the implementation of above idea.

C++

 `// c++ program to count cross line in array``#include ``using` `namespace` `std;` `// Merges two subarrays of arr[].``// First subarray is arr[l..m]``// Second subarray is arr[m+1..r]``void` `merge(``int` `arr[], ``int` `l, ``int` `m, ``int` `r, ``int``* count_crossline)``{``    ``int` `i, j, k;``    ``int` `n1 = m - l + 1;``    ``int` `n2 = r - m;` `    ``/* create temp arrays */``    ``int` `L[n1], R[n2];` `    ``/* Copy data to temp arrays L[] and R[] */``    ``for` `(i = 0; i < n1; i++)``        ``L[i] = arr[l + i];``    ``for` `(j = 0; j < n2; j++)``        ``R[j] = arr[m + 1 + j];` `    ``/* Merge the temp arrays back into arr[l..r]*/``    ``i = 0; ``// Initial index of first subarray``    ``j = 0; ``// Initial index of second subarray``    ``k = l; ``// Initial index of merged subarray``    ``while` `(i < n1 && j < n2) {``        ``if` `(L[i] <= R[j]) {``            ``arr[k] = L[i];``            ``i++;``        ``}``        ``else` `{``            ``arr[k] = R[j];` `            ``//====================================//``            ``//======= MAIN PORTION OF CODE ======//``            ``//===================================//``            ``// add all line which is cross by current element``            ``*count_crossline += (n1 - i);``            ``j++;``        ``}``        ``k++;``    ``}` `    ``/* Copy the remaining elements of L[], if there``    ``are any */``    ``while` `(i < n1) {``        ``arr[k] = L[i];``        ``i++;``        ``k++;``    ``}` `    ``/* Copy the remaining elements of R[], if there``    ``are any */``    ``while` `(j < n2) {``        ``arr[k] = R[j];``        ``j++;``        ``k++;``    ``}``}` `/* l is for left index and r is right index of the``sub-array of arr to be sorted */``void` `mergeSort(``int` `arr[], ``int` `l, ``int` `r, ``int``* count_crossline)``{``    ``if` `(l < r) {` `        ``// Same as (l+r)/2, but avoids overflow for``        ``// large l and h``        ``int` `m = l + (r - l) / 2;` `        ``// Sort first and second halves``        ``mergeSort(arr, l, m, count_crossline);``        ``mergeSort(arr, m + 1, r, count_crossline);` `        ``merge(arr, l, m, r, count_crossline);``    ``}``}` `// function return count of cross line in an array``int` `countCrossLine(``int` `arr[], ``int` `n)``{``    ``int` `count_crossline = 0;``    ``mergeSort(arr, 0, n - 1, &count_crossline);` `    ``return` `count_crossline;``}` `// driver program to test above function``int` `main()``{``    ``int` `arr[] = { 12, 11, 13, 5, 6, 7 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``cout << countCrossLine(arr, n) << endl;``    ``return` `0;``}`

Java

 `// Java program to count cross line in array``import` `java.util.*;` `class` `GFG``{``    ``static` `int` `count_crossline;``    ` `    ``// Merges two subarrays of arr[].``    ``// First subarray is arr[l..m]``    ``// Second subarray is arr[m+1..r]``    ``static` `void` `merge(``int` `arr[], ``int` `l, ``int` `m, ``int` `r)``    ``{``        ``int` `i, j, k;``        ``int` `n1 = m - l + ``1``;``        ``int` `n2 = r - m;` `        ``/* create temp arrays */``        ``int``[] L = ``new` `int``[n1];``        ``int``[] R = ``new` `int``[n2];` `        ``/* Copy data to temp arrays L[] and R[] */``        ``for` `(i = ``0``; i < n1; i++)``        ``{``            ``L[i] = arr[l + i];``        ``}``        ``for` `(j = ``0``; j < n2; j++)``        ``{``            ``R[j] = arr[m + ``1` `+ j];``        ``}` `        ``/* Merge the temp arrays back into arr[l..r]*/``        ``i = ``0``; ``// Initial index of first subarray``        ``j = ``0``; ``// Initial index of second subarray``        ``k = l; ``// Initial index of merged subarray``        ``while` `(i < n1 && j < n2)``        ``{``            ``if` `(L[i] <= R[j])``            ``{``                ``arr[k] = L[i];``                ``i++;``            ``}``            ``else``            ``{``                ``arr[k] = R[j];` `                ``//====================================//``                ``//======= MAIN PORTION OF CODE ======//``                ``//===================================//``                ``// add all line which is cross by current element``                ``count_crossline += (n1 - i);``                ``j++;``            ``}``            ``k++;``        ``}` `        ``/* Copy the remaining elements of L[],``        ``if there are any */``        ``while` `(i < n1)``        ``{``            ``arr[k] = L[i];``            ``i++;``            ``k++;``        ``}` `        ``/* Copy the remaining elements of R[],``        ``if there are any */``        ``while` `(j < n2)``        ``{``            ``arr[k] = R[j];``            ``j++;``            ``k++;``        ``}``    ``}` `    ``/* l is for left index and r is right index of the``    ``sub-array of arr to be sorted */``    ``static` `void` `mergeSort(``int` `arr[], ``int` `l, ``int` `r)``    ``{``        ``if` `(l < r)``        ``{` `            ``// Same as (l+r)/2, but avoids overflow for``            ``// large l and h``            ``int` `m = l + (r - l) / ``2``;` `            ``// Sort first and second halves``            ``mergeSort(arr, l, m);``            ``mergeSort(arr, m + ``1``, r);` `            ``merge(arr, l, m, r);``        ``}``    ``}` `    ``// function return count of cross line in an array``    ``static` `int` `countCrossLine(``int` `arr[], ``int` `n)``    ``{``        ``mergeSort(arr, ``0``, n - ``1``);` `        ``return` `count_crossline;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr[] = {``12``, ``11``, ``13``, ``5``, ``6``, ``7``};``        ``int` `n = arr.length;``        ``System.out.println(countCrossLine(arr, n));``    ``}``}` `// This code is contributed by PrinciRaj1992`

C#

 `// C# program to count cross line in array``using` `System;` `class` `GFG``{``    ``static` `int` `count_crossline;``    ` `    ``// Merges two subarrays of []arr.``    ``// First subarray is arr[l..m]``    ``// Second subarray is arr[m+1..r]``    ``static` `void` `merge(``int` `[]arr, ``int` `l,``                        ``int` `m, ``int` `r)``    ``{``        ``int` `i, j, k;``        ``int` `n1 = m - l + 1;``        ``int` `n2 = r - m;` `        ``/* create temp arrays */``        ``int``[] L = ``new` `int``[n1];``        ``int``[] R = ``new` `int``[n2];` `        ``/* Copy data to temp arrays L[] and R[] */``        ``for` `(i = 0; i < n1; i++)``        ``{``            ``L[i] = arr[l + i];``        ``}``        ``for` `(j = 0; j < n2; j++)``        ``{``            ``R[j] = arr[m + 1 + j];``        ``}` `        ``/* Merge the temp arrays back into arr[l..r]*/``        ``i = 0; ``// Initial index of first subarray``        ``j = 0; ``// Initial index of second subarray``        ``k = l; ``// Initial index of merged subarray``        ``while` `(i < n1 && j < n2)``        ``{``            ``if` `(L[i] <= R[j])``            ``{``                ``arr[k] = L[i];``                ``i++;``            ``}``            ``else``            ``{``                ``arr[k] = R[j];` `                ``//====================================//``                ``//======= MAIN PORTION OF CODE ======//``                ``//===================================//``                ``// add all line which is cross by current element``                ``count_crossline += (n1 - i);``                ``j++;``            ``}``            ``k++;``        ``}` `        ``/* Copy the remaining elements of L[],``        ``if there are any */``        ``while` `(i < n1)``        ``{``            ``arr[k] = L[i];``            ``i++;``            ``k++;``        ``}` `        ``/* Copy the remaining elements of R[],``        ``if there are any */``        ``while` `(j < n2)``        ``{``            ``arr[k] = R[j];``            ``j++;``            ``k++;``        ``}``    ``}` `    ``/* l is for left index and r is right index of the``    ``sub-array of arr to be sorted */``    ``static` `void` `mergeSort(``int` `[]arr, ``int` `l, ``int` `r)``    ``{``        ``if` `(l < r)``        ``{` `            ``// Same as (l+r)/2, but avoids overflow for``            ``// large l and h``            ``int` `m = l + (r - l) / 2;` `            ``// Sort first and second halves``            ``mergeSort(arr, l, m);``            ``mergeSort(arr, m + 1, r);` `            ``merge(arr, l, m, r);``        ``}``    ``}` `    ``// function return count of cross line in an array``    ``static` `int` `countCrossLine(``int` `[]arr, ``int` `n)``    ``{``        ``mergeSort(arr, 0, n - 1);` `        ``return` `count_crossline;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int` `[]arr = {12, 11, 13, 5, 6, 7};``        ``int` `n = arr.Length;``        ``Console.WriteLine(countCrossLine(arr, n));``    ``}``}` `// This code is contributed by PrinciRaj1992`

Javascript

 ``

Output:

`>10`

Time complexity: O(nlogn)
Reference: https://www.careercup.com/question?id=5669565693427712
This article is contributed by Nishant Singh . If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.