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++ program to count cross line in array #include <bits/stdc++.h> 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 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 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# 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 // PHP program to count // cross line in array // Function return count // of cross line in an array function countCrossLine( $arr , $n )
{ $count_crossline = 0;
$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 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. ?> |
<script> // Javascript program to count cross line in array // function return count of cross line in an array function countCrossLine( arr, n)
{ let count_crossline = 0;
let 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 let arr = [ 4, 3, 1, 2 ];
let n = arr.length;
document.write(countCrossLine(arr, n) + "</br" );
</script> |
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
Below is the implementation of above idea.
// c++ program to count cross line in array #include <bits/stdc++.h> 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 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 |
# Python program to count cross line in array count_crossline = 0
# Merges two subarrays of arr[]. # First subarray is arr[l..m] # Second subarray is arr[m+1..r] def merge(arr,l,m,r):
global count_crossline
n1 = m - l + 1
n2 = r - m
# create temp arrays
L = [ 0 ] * n1
R = [ 0 ] * n2
# Copy data to temp arrays L[] and R[]
for i in range (n1):
L[i] = arr[l + i]
for j in range (n2):
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 and j<n2):
if (L[i]< = R[j]):
arr[k] = L[i]
i + = 1
else :
arr[k] = R[j]
# ====================================
# ======= MAIN PORTION OF CODE ======
# ===================================
# add all line which is cross by current element
count_crossline + = (n1 - i)
j + = 1
k + = 1
# Copy the remaining elements of L[], if there
# are any
while (i<n1):
arr[k] = L[i]
i + = 1
k + = 1
# Copy the remaining elements of R[], if there
# are any
while (j<n2):
arr[k] = R[j]
j + = 1
k + = 1
# l is for left index and r is right index of the # sub-array of arr to be sorted def mergeSort(arr,l,r):
if (l<r):
# Same as (l+r)/2, but avoids overflow for
# large l and h
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 def countCrossLine(arr,n):
mergeSort(arr, 0 ,n - 1 )
return count_crossline
# driver program to test above function arr = [ 12 , 11 , 13 , 5 , 6 , 7 ]
n = len (arr)
print (countCrossLine(arr,n))
# This code is contributed by Pushpesh Raj. |
// 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 |
<script> // Javascript program to count cross line in array let count_crossline = 0;
// Merges two subarrays of arr[].
// First subarray is arr[l..m]
// Second subarray is arr[m+1..r]
function merge(arr, l, m, r)
{
let i, j, k;
let n1 = m - l + 1;
let n2 = r - m;
/* create temp arrays */
let L = [];
let R = [];
/* 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 */
function mergeSort(arr, l, r)
{
if (l < r)
{
// Same as (l+r)/2, but avoids overflow for
// large l and h
let m = l + Math.floor((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
function countCrossLine(arr, n)
{
mergeSort(arr, 0, n - 1);
document.write(count_crossline);
}
// Driver code let arr = [12, 11, 13, 5, 6, 7];
let n = arr.length;
countCrossLine(arr, n);
// This code is contributed by code_hunt.
</script> |
Output:
10
Time complexity: O(nlogn)
Auxiliary Space: O(n)
Reference: https://www.careercup.com/question?id=5669565693427712