Find maximum value of Indices of Array that satisfy the given conditions

Given an integer N (N ? 5) Then assume you have two infinite arrays X and Y where X[] is an array of element N and each element of Y[] is 2ⁱ where i is the index of the array, the task is to find two indices let's say A and B which are the maximum value of the index at which the prefix sum in X[] is at least the same as the prefix sum of Y[] and the index value at which the X[i] - Y[i] is maximum respectively, Where The value of B should be less than or equal to A. Formally, B ? A.

Examples:

Input: N = 7
Output: A = 5, B = 3
Explanation: Y[] = {1, 2, 4, 8....., 2i - n}, X[] = {7, 7, 7, 7, .....7}
The sum of X[] till index 5 is: 35 
The sum of Y[] till index 5 is: 31
5 is the maximum value of index at which, The sum of elements of X[] is strictly greater than or equal to Y[]. Maximum possible difference of sum(Xi - Yi) is at index 3, Which is 14. Therefore, A = 5 and B = 3.

Input: N = 6
Output: A = 4, B = 3
Explanation: It can be verified that 4 is maximum possible value of index at which sum of elements of X[] is strictly greater than or equal to Y[] and max difference is at index 3. Therefore, A = 4 and B = 3.

Approach: Implement the idea below to solve the problem:

Take two long data type integers lets say K and L to store sum of X and Y respectively, run a while loop till the sum difference is greater than or equal to zero. 

Follow the steps to solve the problem:

• Take two long data type variables let's say K and L to store the sum of X[] and Y[] respectively till index i, other two integers A and B for output as discussed in the problem statement. 
• Take another variable Z, and initialize it to 0, Which will use to store the difference at index i as X[i] - Y[i]. Run a While loop till Z ? 0, and follow the below steps inside the loop :
  • Update the value of K and L.
  • Update the value of Z as Xi - Yi.
  • Increment A.
  • If Z is the maximum current value of the index at i, Then update B as i.
• Print the value of A and B.  

Below is the code to implement the above approach:

// C++ code for the above approach
#include <bits/stdc++.h>
using namespace std;

static void calculateIndices(int N)
{
    // Variable to store difference at
    // each iteration of while Loop
    long Z = 0;

    // Counter for calculating
    // power of 2
    long Pow_counter = 1;

    // Variable K to store sum of
    // elements of X[]
    long K = 0;

    // Variable K to store sum of
    // elements of X[]
    long L = 0;

    // Variable to store Max value of
    // index at which Z >= 0
    long A = 0;

    // Variable to store Max value of
    // index at which Z is maximum in
    // all iterations of while loop
    long B = 0;

    // max variable to store maximum
    // value of Z
    long max = LONG_MIN;

    // While loop to execute
    // till Z >= 0
    while (Z >= 0) {

        // Updating value of K
        K += N;

        // Updating value of L
        L += pow(2, Pow_counter - 1);

        // Incrementing A
        A++;

        // Updating value of Z
        Z = K - L;

        // If Z is maxed till now
        if (Z > max) {

            // Update max variable as Z
            max = Z;

            // Update B as max_counter
            B = Pow_counter;
        }

        // Incrementing variable
        // Pow_counter, if Z is
        // non-negative(Z >= 0)
        if (Z >= 0)
            Pow_counter++;
    }

    // Printing value of Z
    cout << (A - 1) << " " << B << endl;
}

// Driver code
int main()
{
    long N = 6;
    calculateIndices(N);
    return 0;
}

// This code is contributed by Tapesh(tapeshdua420)

// Java code for the above approach

import java.io.*;
import java.lang.*;
import java.util.*;

class GFG {

    static void calculateIndices(long N)
    {
        // Variable to store difference at
        // each iteration of while Loop
        long Z = 0;

        // Counter for calculating
        // power of 2
        long Pow_counter = 1;

        // Variable K to store sum of
        // elements of X[]
        long K = 0;

        // Variable K to store sum of
        // elements of X[]
        long L = 0;

        // Variable to store Max value of
        // index at which Z >= 0
        long A = 0;

        // Variable to store Max value of
        // index at which Z is maximum in
        // all iterations of while loop
        long B = 0;

        // max variable to store maximum
        // value of Z
        long max = Long.MIN_VALUE;

        // While loop to execute
        // till Z >= 0
        while (Z >= 0) {

            // Updating value of K
            K += N;

            // Updating value of L
            L += Math.pow(2, Pow_counter - 1);

            // Incrementing A
            A++;

            // Updating value of Z
            Z = K - L;

            // If Z is maxed till now
            if (Z > max) {

                // Update max variable as Z
                max = Z;

                // Update B as max_counter
                B = Pow_counter;
            }

            // Incrementing variable
            // Pow_counter, if Z is
            // non-negative(Z >= 0)
            if (Z >= 0)
                Pow_counter++;
        }

        // Printing value of Z
        System.out.println((A - 1) + " " + B);
    }

    // Driver code
    public static void main(String args[])
    {
        long N = 6;
        calculateIndices(N);
    }
}

# Python code for the above approach
import math

# Function to calculate indices
def calculateIndices(N):

    # Variable to store difference at
    # each iteration of while Loop
    Z = 0

    # Counter for calculating
    # power of 2
    Pow_counter = 1

    # Variable K to store sum of
    # elements of X[]
    K = 0

    # Variable K to store sum of
    # elements of X[]
    L = 0

    # Variable to store Max value of
    # index at which Z >= 0
    A = 0

    # Variable to store Max value of
    # index at which Z is maximum in
    # all iterations of while loop
    B = 0

    # max variable to store maximum
    # value of Z
    max = -math.inf

    # While loop to execute
    # till Z >= 0
    while (Z >= 0):

        # Updating value of K
        K += N

        # Updating value of L
        L += pow(2, Pow_counter - 1)

        # Incrementing A
        A += 1

        # Updating value of Z
        Z = K - L

        # If Z is maxed till now
        if (Z > max):

            # Update max variable as Z
            max = Z

            # Update B as max_counter
            B = Pow_counter

        # Incrementing variable
        # Pow_counter, if Z is
        # non-negative(Z >= 0)
        if (Z >= 0):
            Pow_counter += 1

    # Printing value of Z
    print(A - 1, B)


# Driver code
N = 6
calculateIndices(N)

# This code is contributed by Tapesh(tapeshdua420)

// C# code for the above approach

using System;

public class GFG{
  
      static void calculateIndices(long N)
    {
        // Variable to store difference at
        // each iteration of while Loop
        long Z = 0;
  
        // Counter for calculating
        // power of 2
        long Pow_counter = 1;
  
        // Variable K to store sum of
        // elements of X[]
        long K = 0;
  
        // Variable K to store sum of
        // elements of X[]
        long L = 0;
  
        // Variable to store Max value of
        // index at which Z >= 0
        long A = 0;
  
        // Variable to store Max value of
        // index at which Z is maximum in
        // all iterations of while loop
        long B = 0;
  
        // max variable to store maximum
        // value of Z
        long max = Int64.MinValue;
  
        // While loop to execute
        // till Z >= 0
        while (Z >= 0) {
  
            // Updating value of K
            K += N;
  
            // Updating value of L
            L += (long)Math.Pow(2, Pow_counter - 1);
  
            // Incrementing A
            A++;
  
            // Updating value of Z
            Z = K - L;
  
            // If Z is maxed till now
            if (Z > max) {
  
                // Update max variable as Z
                max = Z;
  
                // Update B as max_counter
                B = Pow_counter;
            }
  
            // Incrementing variable
            // Pow_counter, if Z is
            // non-negative(Z >= 0)
            if (Z >= 0)
                Pow_counter++;
        }
  
        // Printing value of Z
        Console.WriteLine((A - 1) + " " + B);
    }

    static public void Main (){

        // Code
          long N = 6;
        calculateIndices(N);
    }
}

// This code is contributed by lokeshmvs21.

<script>
  // JavaScript code for the above approach

  function calculateIndices(N) {
      // Variable to store difference at
      // each iteration of while Loop
      var Z = 0;

      // Counter for calculating
      // power of 2
      var Pow_counter = 1;

      // Variable K to store sum of
      // elements of X[]
      var K = 0;

      // Variable K to store sum of
      // elements of X[]
      var L = 0;

      // Variable to store Max value of
      // index at which Z >= 0
      var A = 0;

      // Variable to store Max value of
      // index at which Z is maximum in
      // all iterations of while loop
      var B = 0;

      // max variable to store maximum
      // value of Z
      var max = -Infinity;

      // While loop to execute
      // till Z >= 0
      while (Z >= 0) {

          // Updating value of K
          K += N;

          // Updating value of L
          L += Math.pow(2, Pow_counter - 1);

          // Incrementing A
          A += 1;

          // Updating value of Z
          Z = K - L;

          // If Z is maxed till now
          if (Z > max) {

              // Update max variable as Z
              max = Z;

              // Update B as max_counter
              B = Pow_counter;
          }

          // Incrementing variable
          // Pow_counter, if Z is
          // non-negative(Z >= 0)
          if (Z >= 0) {
              Pow_counter += 1;
          }
      }

      // Printing value of Z
      console.log(A - 1, B);
  }

  // Driver code
  var N = 6;
  calculateIndices(N);

  // This code is contributed by Tapesh(tapeshdua420)
</script>

4 3

Time Complexity: O(A)
Auxiliary Space: O(1)