Given two integers N and B, the task is to print the maximum index in an array that can be reached, starting from the 0th index, in N steps without placing itself at index B at any point, where in every ith step, pointer can move i indices to the right.
Examples:
Input: N = 4, B = 6
Output: 9
Explanation: Following sequence of moves maximizes the index that can be reached.
- Step 1: Initially, pos = 0. Remain in the same position.
- Step 2: Move 2 indices to the right. Therefore, current position = 0 + 2 = 2.
- Step 3: Move 3 indices to the right. Therefore, current position = 2 + 3 = 5.
- Step 4: Move 4 indices to the right. Therefore, current position = 5 + 4 = 9.
Input: N = 2, B = 2
Output: 3
Naive Approach: Refer to the previous post for the simplest approach to solve the problem.
Time Complexity: O(N3)
Auxiliary Space: O(1)
Efficient Approach: The most optimal idea to solve the problem is based on the following observations:
Observation:
- If observed carefully, the answer is either the sequence from the arithmetic sum of steps or that of the arithmetic sum of steps – 1.
- This is because, the highest possible number without considering B, is reachable by not waiting (which would give the arithmetic sum).
- But if B is a part of that sequence, then waiting at 0 in the first steps ensures that the sequence does not intersect with the sequence obtained without waiting (as it is always 1 behind).
- Any other sequence (i.e waiting at any other point once or more number of times) will always yield a smaller maximum reachable index.
Follow the steps below to solve the problem:
- Initialize two pointers i = 0 and j = 1.
- Initialize a variable, say sum, to store the sum of first N natural numbers, i.e. N * (N + 1) / 2.
- Initialize a variable, say cnt = 0 and another variable, say flag = false.
- Iterate until cnt is less than N.
- Increment i with j.
- Increment j.
- Increment cnt.
- If at any iteration, i is equal to B, set flag = true and break out of the loop.
- If flag is false, then print sum. Otherwise, print sum – 1.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int maximumIndex(int N, int B)
{
int i = 0, j = 1;
int cnt = 0;
int sum = N * (N + 1) / 2;
bool flag = false;
while (cnt < N) {
i += j;
j++;
cnt++;
if (i == B) {
flag = true;
break;
}
}
if (!flag) {
cout << sum;
}
else
cout << sum - 1;
}
int main()
{
int N = 4, B = 6;
maximumIndex(N, B);
return 0;
}
|
Java
class GFG{
static void maximumIndex(int N, int B)
{
int i = 0, j = 1;
int cnt = 0;
int sum = N * (N + 1) / 2;
boolean flag = false;
while (cnt < N)
{
i += j;
j++;
cnt++;
if (i == B)
{
flag = true;
break;
}
}
if (!flag == true)
{
System.out.print(sum);
}
else
{
System.out.print(sum - 1);
}
}
public static void main (String[] args)
{
int N = 4, B = 6;
maximumIndex(N, B);
}
}
|
Python3
def maximumIndex(N, B):
i, j = 0, 1
cnt = 0
sum = N * (N + 1) // 2
flag = False
while (cnt < N):
i += j
j += 1
cnt += 1
if (i == B):
flag = True
break
if (not flag):
print (sum)
else:
print(sum - 1)
if __name__ == '__main__':
N, B = 4, 6
maximumIndex(N, B)
|
C#
using System;
class GFG{
static void maximumIndex(int N, int B)
{
int i = 0, j = 1;
int cnt = 0;
int sum = N * (N + 1) / 2;
bool flag = false;
while (cnt < N)
{
i += j;
j++;
cnt++;
if (i == B)
{
flag = true;
break;
}
}
if (!flag == true)
{
Console.Write(sum);
}
else
{
Console.Write(sum - 1);
}
}
static public void Main ()
{
int N = 4, B = 6;
maximumIndex(N, B);
}
}
|
Javascript
<script>
function maximumIndex(N, B)
{
let i = 0, j = 1;
let cnt = 0;
let sum = Math.floor(N * (N + 1) / 2);
let flag = false;
while (cnt < N) {
i += j;
j++;
cnt++;
if (i == B) {
flag = true;
break;
}
}
if (!flag) {
document.write(sum);
}
else
document.write(sum - 1);
}
let N = 4, B = 6;
maximumIndex(N, B);
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(1)
Another Efficient Approach:
In the previous approach, we have established that the minimum value can never be less than the (total sum of N natural number) – 1.
In this approach, we will try to find if B can occur in any of the steps in a more optimal way.
- The idea is to use the quadratic equation formula to retrieve if there exists a valid number x for which (x)(x+1)/2 = B.
- Since, B is already given, we can rewrite the equation as x2 + x – 2B = 0.
- Using the quadratic formula, we can identify if x is a valid integer which satisfies this condition.
- If find a valid x, we can return (N)(N+1)/2 – 1. Else, we can directly return (N)(N+1)/2.
Below is the implementation of the approach discussed:
C++
#include <iostream>
#include <math.h>
using namespace std;
bool isNaturalSum(int B){
float x=(-1+sqrt(1+8*B))/2;
if(ceil(x)==floor(x))
return true;
else
return false;
}
int maximumIndex(int N, int B){
long long int max_sum = ((N)*(N+1))/2;
bool is_B_reachable = isNaturalSum(B);
if(is_B_reachable){
return max_sum - 1;
}
else{
return max_sum;
}
}
int main()
{
int N = 3, B = 6;
cout<<maximumIndex(N, B)<<endl;
return 0;
}
|
Java
import java.util.*;
public class GFG {
public static boolean isNaturalSum(int B) {
double x = (-1 + Math.sqrt(1 + 8 * B)) / 2;
return Math.ceil(x) == Math.floor(x);
}
public static int maximumIndex(int N, int B) {
int maxSum = (N * (N + 1)) / 2;
boolean isBReachable = isNaturalSum(B);
return isBReachable? maxSum - 1 : maxSum;
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int N = 3;
int B = 6;
System.out.println(maximumIndex(N, B));
scanner.close();
}
}
|
Python3
import math
def isNaturalSum(B):
x = (-1 + math.sqrt(1 + 8*B))/2
if math.ceil(x) == math.floor(x):
return True
else:
return False
def maximumIndex(N, B):
max_sum = ((N)*(N+1))//2
is_B_reachable = isNaturalSum(B)
if is_B_reachable:
return max_sum - 1
else:
return max_sum
N = 3
B = 6
print(maximumIndex(N, B))
|
Javascript
function isNaturalSum(B) {
var x = (-1 + Math.sqrt(1 + 8 * B)) / 2;
if (Math.ceil(x) === Math.floor(x)) {
return true;
} else {
return false;
}
}
function maximumIndex(N, B) {
var max_sum = (N * (N + 1)) / 2;
var is_B_reachable = isNaturalSum(B);
if (is_B_reachable) {
return max_sum - 1;
} else {
return max_sum;
}
}
var N = 3;
var B = 6;
console.log(maximumIndex(N, B));
|
C#
using System;
class GFG
{
public static bool IsNaturalSum(int B)
{
double x = (-1 + Math.Sqrt(1 + 8 * B)) / 2;
return Math.Ceiling(x) == Math.Floor(x);
}
public static int MaximumIndex(int N, int B)
{
int maxSum = (N * (N + 1)) / 2;
bool isBReachable = IsNaturalSum(B);
return isBReachable ? maxSum - 1 : maxSum;
}
public static void Main(string[] args)
{
int N = 3;
int B = 6;
Console.WriteLine(MaximumIndex(N, B));
}
}
|
Time Complexity: O(1)
Auxiliary Space: O(1)