Given some rules to generate an N × N matrix mat[][] and two integers R and C, the task is to find the element at the Rth row and Cth column. The rules are as follows:
- The first row is an AP series starting with 1 and d = 1 (Common Difference).
- For all the elements at (i, j) such that i > j, their value is 0.
- Rest of the elements follow, Element(i, j) = Element(i – 1, j) + Element(i – 1, j – 1).
Examples:
Input: N = 4, R = 3, C = 4
Output: 12
mat[][] =
{1, 2, 3, 4},
{0, 3, 5, 7},
{0, 0, 8, 12},
{0, 0, 0, 20}
and the element in the third row and fourth column is 12.
Input: N = 2, R = 2, C = 2
Output: 3
Approach:
- The basic key is to observe the pattern, first observation is that every row will have an AP after the element at (i, i). The common difference for row number j is pow(2, j – 1).
- Now we need to find the first term of each row to find any element (R, C). If we consider only starting elements in each row (i.e element at diagonal), we can observe it is equal to (R + 1) * pow(2, R – 2) for every row R from 2 to N.
- So, If R > C then the element is 0 else C – R is the position of the required element in AP which is present in the Rth row for which we already know the starting term and the common difference. So, we can find the element as start + d * (C – R).
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int getElement( int N, int r, int c)
{
if (r > c)
return 0;
if (r == 1) {
return c;
}
int a = (r + 1) * pow (2, r - 2);
int d = pow (2, r - 1);
c = c - r;
int element = a + d * c;
return element;
}
int main()
{
int N = 4, R = 3, C = 4;
cout << getElement(N, R, C);
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class GFG
{
static int getElement( int N, int r, int c)
{
if (r > c)
return 0 ;
if (r == 1 )
{
return c;
}
int a = (r + 1 ) * ( int )(Math.pow( 2 ,(r - 2 )));
int d = ( int )(Math.pow( 2 ,(r - 1 )));
c = c - r;
int element = a + d * c;
return element;
}
public static void main(String[] args)
{
int N = 4 , R = 3 , C = 4 ;
System.out.println(getElement(N, R, C));
}
}
|
Python3
def getElement(N, r, c) :
if (r > c) :
return 0 ;
if (r = = 1 ) :
return c;
a = (r + 1 ) * pow ( 2 , r - 2 );
d = pow ( 2 , r - 1 );
c = c - r;
element = a + d * c;
return element;
if __name__ = = "__main__" :
N = 4 ; R = 3 ; C = 4 ;
print (getElement(N, R, C));
|
C#
using System;
class GFG
{
static int getElement( int N, int r, int c)
{
if (r > c)
return 0;
if (r == 1)
{
return c;
}
int a = (r + 1) * ( int )(Math.Pow(2,(r - 2)));
int d = ( int )(Math.Pow(2,(r - 1)));
c = c - r;
int element = a + d * c;
return element;
}
public static void Main(String[] args)
{
int N = 4, R = 3, C = 4;
Console.WriteLine(getElement(N, R, C));
}
}
|
Javascript
<script>
function getElement( N, r, c)
{
if (r > c)
return 0;
if (r == 1)
{
return c;
}
let a = (r + 1) * parseInt(Math.pow(2,(r - 2)));
let d = parseInt(Math.pow(2,(r - 1)));
c = c - r;
let element = a + d * c;
return element;
}
let N = 4, R = 3, C = 4;
document.write(getElement(N, R, C));
</script>
|
Time Complexity : O(logr)
Auxiliary Space: O(1)