Skip to content
Related Articles

Related Articles

Improve Article

Number of positions with Same address in row major and column major order

  • Difficulty Level : Easy
  • Last Updated : 24 May, 2021

Given a 2D array of size M x N. Calculate count of positions in 2D array where address as per row-major order equals to address as per column-major order. 
Examples: 
 

Input : 3 5 
Output : 3 
Row major address is same as column major for following i, j 
pairs (1, 1), (2, 3) & (3, 5)
 

Input : 4 4 
Output : 4 
 

 



Let’s consider element with index i, j 
 

Row major address = B + w * (N * (i-1) + j-1) 
Column major address = B + w * (M * (j-1) + i-1) 

B: Base address of the array 
w: Size of each element of the array
 

Equating both addresses, we get
B + w * (N * (i-1) + j-1)  = B + w * (M * (j-1) + i-1)
N * (i-1) + j  = M * (j-1) + i
N*i - N + j  = M*j - M + i
M*j - j = N*i - N + M - i
(M-1) * j = N*i - N + M - i
j = (N*i - N + M - i)/(M-1)    - (Eq. 1)
Similarly
i = (M*j - M + N - j)/(N-1)    - (Eq. 2)

Now we have established a relation between i and j 
 

Iterate for all possible i and find corresponding j 
If j comes out to be an integer in the range 1 to N, 
increment the counter. 

Below is the implementation of above approach. 
 

C++




// CPP Program to count the number
// of positions with same address
// in row major and column major order
#include <bits/stdc++.h>
 
using namespace std;
 
// Returns count of required positions
int getCount(int M, int N)
{
    int count = 0;
 
    // horizontal 1D array
    if (M == 1)
        return N;
 
    // vertical 1D array
    if (N == 1)
        return M;
 
    if (N > M) {
 
        // iterating for all possible i
        for (int i = 1; i <= M; i++) {
            int numerator = N * i - N + M - i;
            int denominator = M - 1;
 
            // checking if j is integer
            if (numerator % denominator == 0) {
                int j = numerator / denominator;
 
                // checking if j lies b/w 1 to N
                if (j >= 1 && j <= N)
                    count++;
            }
        }
    }
    else {
 
        // iterating for all possible j
        for (int j = 1; j <= N; j++) {
            int numerator = M * j - M + N - j;
            int denominator = N - 1;
 
            // checking if i is integer
            if (numerator % denominator == 0) {
                int i = numerator / denominator;
 
                // checking if i lies b/w 1 to M
                if (i >= 1 && i <= M)
                    count++;
            }
        }
    }
    return count;
}
 
// Driver Code
int main()
{
    int M = 3, N = 5;
    cout << getCount(M, N) << endl;
    return 0;
}

Java




// Java Program to count the number
// of positions with same address
// in row major and column major order
import java.io.*;
class GFG {
 
// Returns count of
// required positions
static int getCount(int M, int N)
{
    int count = 0;
 
    // horizontal 1D array
    if (M == 1)
        return N;
 
    // vertical 1D array
    if (N == 1)
        return M;
 
    if (N > M) {
 
        // iterating for all possible i
        for (int i = 1; i <= M; i++) {
            int numerator = N * i - N + M - i;
            int denominator = M - 1;
 
            // checking if j is integer
            if (numerator % denominator == 0) {
                int j = numerator / denominator;
 
                // checking if j lies b/w 1 to N
                if (j >= 1 && j <= N)
                    count++;
            }
        }
    }
    else {
 
        // iterating for all possible j
        for (int j = 1; j <= N; j++) {
            int numerator = M * j - M + N - j;
            int denominator = N - 1;
 
            // checking if i is integer
            if (numerator % denominator == 0) {
                int i = numerator / denominator;
 
                // checking if i lies b/w 1 to M
                if (i >= 1 && i <= M)
                    count++;
            }
        }
    }
    return count;
}
 
    // Driver Code
    public static void main (String[] args)
    {
        int M = 3, N = 5;
        System.out.println( getCount(M, N));
    }
}
 
// This code is contributed by vt_m.

Python3




# Python3 Program to count the number
# of positions with same address
# in row major and column major order
 
# Returns count of
# required positions
def getCount(M, N):
    count = 0;
 
    # horizontal 1D array
    if (M == 1):
        return N;
 
    # vertical 1D array
    if (N == 1):
        return M;
 
    if (N > M):
 
        # iterating for all possible i
        for i in range(1, M + 1):
            numerator = N * i - N + M - i;
            denominator = M - 1;
 
            # checking if j is integer
            if (numerator % denominator == 0):
                j = numerator / denominator;
 
                # checking if j lies b/w 1 to N
                if (j >= 1 and j <= N):
                    count += 1;
    else:
 
        # iterating for all possible j
        for j in range(1, N + 1):
            numerator = M * j - M + N - j;
            denominator = N - 1;
 
            # checking if i is integer
            if (numerator % denominator == 0):
                i = numerator / denominator;
 
                # checking if i lies b/w 1 to M
                if (i >= 1 and i <= M):
                    count += 1;
 
    return count;
 
# Driver Code
if __name__ == '__main__':
    M, N = 3, 5;
    print(getCount(M, N));
 
# This code is contributed by Rajput-Ji

C#




// C# Program to count the number
// of positions with same address
// in row major and column major order
using System;
class GFG {
 
    // Returns count of
    // required positions
    static int getCount(int M, int N)
    {
        int count = 0;
     
        // horizontal 1D array
        if (M == 1)
            return N;
     
        // vertical 1D array
        if (N == 1)
            return M;
     
        if (N > M) {
     
            // iterating for all possible i
            for (int i = 1; i <= M; i++) {
                int numerator = N * i - N + M - i;
                int denominator = M - 1;
     
                // checking if j is integer
                if (numerator % denominator == 0) {
                    int j = numerator / denominator;
     
                    // checking if j lies b/w 1 to N
                    if (j >= 1 && j <= N)
                        count++;
                }
            }
        }
        else {
     
            // iterating for all possible j
            for (int j = 1; j <= N; j++) {
                int numerator = M * j - M + N - j;
                int denominator = N - 1;
     
                // checking if i is integer
                if (numerator % denominator == 0) {
                    int i = numerator / denominator;
     
                    // checking if i lies b/w 1 to M
                    if (i >= 1 && i <= M)
                        count++;
                }
            }
        }
        return count;
    }
 
    // Driver Code
    public static void Main ()
    {
        int M = 3, N = 5;
        Console.WriteLine( getCount(M, N));
    }
}
 
// This code is contributed by anuj_67.

PHP




<?php
// PHP Program to count the number
// of positions with same address
// in row major and column major order
 
// Returns count of required positions
function getCount( $M, $N)
{
    $count = 0;
 
    // horizontal 1D array
    if ($M == 1)
        return $N;
 
    // vertical 1D array
    if ($N == 1)
        return $M;
 
    if ($N > $M)
    {
 
        // iterating for all possible i
        for($i = 1; $i <= $M; $i++)
        {
            $numerator = $N * $i - $N + $M - $i;
            $denominator = $M - 1;
 
            // checking if j is integer
            if ($numerator % $denominator == 0)
            {
                $j = $numerator / $denominator;
 
                // checking if j lies b/w 1 to N
                if ($j >= 1 and $j <= $N)
                    $count++;
            }
        }
    }
    else
    {
 
        // iterating for all possible j
        for ( $j = 1; $j <= $N; $j++)
        {
            $numerator = $M * $j - $M + $N - $j;
            $denominator = $N - 1;
 
            // checking if i is integer
            if ($numerator % $denominator == 0)
            {
                $i = $numerator / $denominator;
 
                // checking if i lies b/w 1 to M
                if ($i >= 1 and $i <= $M)
                    $count++;
            }
        }
    }
    return $count;
}
 
    // Driver Code
    $M = 3; $N = 5;
    echo getCount($M, $N) ;
 
// This code is contributed by anuj_67.
?>

Javascript




<script>
 
    // JavaScript Program to count the number
    // of positions with same address
    // in row major and column major order
     
    // Returns count of
    // required positions
    function getCount(M, N)
    {
        let count = 0;
       
        // horizontal 1D array
        if (M == 1)
            return N;
       
        // vertical 1D array
        if (N == 1)
            return M;
       
        if (N > M) {
       
            // iterating for all possible i
            for (let i = 1; i <= M; i++) {
                let numerator = N * i - N + M - i;
                let denominator = M - 1;
       
                // checking if j is integer
                if (numerator % denominator == 0) {
                    let j =
                    parseInt(numerator / denominator, 10);
       
                    // checking if j lies b/w 1 to N
                    if (j >= 1 && j <= N)
                        count++;
                }
            }
        }
        else {
       
            // iterating for all possible j
            for (let j = 1; j <= N; j++) {
                let numerator = M * j - M + N - j;
                let denominator = N - 1;
       
                // checking if i is integer
                if (numerator % denominator == 0) {
                    let i =
                    parseInt(numerator / denominator, 10);
       
                    // checking if i lies b/w 1 to M
                    if (i >= 1 && i <= M)
                        count++;
                }
            }
        }
        return count;
    }
     
    let M = 3, N = 5;
    document.write( getCount(M, N));
     
</script>

Output:  

3

Time Complexity: O(M) 
Complexity can be reduced to O(min(M, N)) by establishing relation of i in terms of j(Eq. 2) and iterating for all possible j in case N<M and by establishing relation j in terms of i(Eq. 1) and iterating for all possible i otherwise.
 

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
Recommended Articles
Page :