Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Minimize operations till a or b exceeds N by replacing a or b with their sum

  • Last Updated : 01 Nov, 2021

Given three integers a, b, and N. The task is to find minimum addition operations between a and b, such that after applying the operations, either of a or b becomes greater than N. An addition operation is defined as replacing either of a or b with their sum and keeping another one intact.

Examples:

Input: a = 2, b = 3, N = 20
Output: 4
Explanation: 

  • Adding 2 and 3, 2 + 3 = 5 and replacing 2 with 5,  now a = 5, b = 3
  • Again add a and b 5 + 3 = 8 replace b with 8, now a = 5, b = 8
  • Again add a and b 5 + 8 = 13 replace a with 13. now a = 13, b = 8
  • Again add a and b 13 + 8 = 21 replace b with 21, now a = 13, b = 21  Here, (b>=n) therefore minimum operations required are 4

Input: a = 2, b = 3, N = 5
Output: 1
Explanation: After replacing 2 with 2+3, a becomes 5 and b becomes 3, therefore minimum operations required are 1 

 

Approach: The idea is to add a and b and store their sum in the minimum of a and b, every time until any of the numbers is greater than N. Reason behind it is making the minimum element largest every time, makes their sum high and thereby reducing the number of operations required.



Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to print the minimum number
// of operations required
int minOperations(int a, int b, int n)
{
 
    // Store the count of operations
    int count = 0;
 
    while (1) {
 
        // If any value is greater than N
        // return count
        if (n <= a or n <= b) {
            return count;
            break;
        }
        else {
            int sum = a + b;
            if (a < b)
                a = sum;
            else
                b = sum;
        }
        count++;
    }
    return count;
}
 
// Driver code
int main()
{
    int p = 2, q = 3, n = 20;
    cout << minOperations(p, q, n) << "\n";
    return 0;
}
Java



// Java program for the above approach
class GFG {
 
    // Function to print the minimum number
    // of operations required
    public static int minOperations(int a, int b, int n) {
 
        // Store the count of operations
        int count = 0;
 
        while (true) {
 
            // If any value is greater than N
            // return count
            if (n <= a || n <= b) {
                return count;
            } else {
                int sum = a + b;
                if (a < b)
                    a = sum;
                else
                    b = sum;
            }
            count++;
        }
    }
 
    // Driver code
    public static void main(String args[]) {
        int p = 2, q = 3, n = 20;
        System.out.println(minOperations(p, q, n));
    }
}
 
// This code is contributed by saurabh_jaiswal.
Python3



# python program for the above approach
 
# Function to print the minimum number
# of operations required
def minOperations(a, b, n):
 
    # Store the count of operations
    count = 0
 
    while (1):
 
        # If any value is greater than N
        # return count
        if (n <= a or n <= b):
            return count
            break
 
        else:
            sum = a + b
            if (a < b):
                a = sum
            else:
                b = sum
 
        count += 1
 
    return count
 
# Driver code
if __name__ == "__main__":
 
    p = 2
    q = 3
    n = 20
    print(minOperations(p, q, n))
 
    # This code is contributed by rakeshsahni
Javascript



<script>
        // JavaScript Program to implement
        // the above approach
 
        // Function to print the minimum number
        // of operations required
        function minOperations(a, b, n) {
 
            // Store the count of operations
            let count = 0;
 
            while (1) {
 
                // If any value is greater than N
                // return count
                if (n <= a || n <= b) {
                    return count;
                    break;
                }
                else {
                    let sum = a + b;
                    if (a < b)
                        a = sum;
                    else
                        b = sum;
                }
                count++;
            }
            return count;
        }
 
        // Driver code
 
        let p = 2, q = 3, n = 20;
        document.write(minOperations(p, q, n) + "<br>");
 
// This code is contributed by Potta Lokesh
    </script>
C#



// C# program for the above approach
using System;
 
public class GFG {
 
    // Function to print the minimum number
    // of operations required
    public static int minOperations(int a, int b, int n) {
 
        // Store the count of operations
        int count = 0;
 
        while (true) {
 
            // If any value is greater than N
            // return count
            if (n <= a || n <= b) {
                return count;
            } else {
                int sum = a + b;
                if (a < b)
                    a = sum;
                else
                    b = sum;
            }
            count++;
        }
    }
 
    // Driver code
    public static void Main(string []args) {
        int p = 2, q = 3, n = 20;
        Console.WriteLine(minOperations(p, q, n));
    }
}
 
// This code is contributed by AnkThon
 
 
Output
4
 
Time Complexity: O(min(log(max(a, N), log(max(b, N)))
Auxiliary Space: O(1)
 



My Personal Notes
arrow_drop_up
Previous
Publicis Sapient ASDE Interview Experience | On-Campus 2021
Next

Minimize swaps to rearrange Array such that remainder of any element and its index with 3 are same
Recommended Articles
Page :
Maximize count of pairs whose Bitwise AND exceeds Bitwise XOR by replacing such pairs with their Bitwise AND
22, Feb 21
Find position i to split Array such that prefix sum till i-1, i and suffix sum till i+1 are in GP with common ratio K
30, Sep 21
Minimize swaps between two arrays such that sum of the first array exceeds sum of the second array
18, Jan 21
Check if a pair of integers from two ranges exists such that their Bitwise XOR exceeds both the ranges
11, Jun 21
Minimize cost to reduce array to a single element by replacing K consecutive elements by their sum
10, Dec 20
Minimize array length by repeatedly replacing pairs of unequal adjacent array elements by their sum
04, Sep 20
Minimize array sum by replacing greater and smaller elements of pairs by half and double of their values respectively atmost K times
11, Nov 20
Minimize remaining array element by repeatedly replacing pairs by half of one more than their sum
09, Nov 20
Minimize remaining array element by removing pairs and replacing them by their absolute difference
04, Dec 20
Minimize remaining array element by removing pairs and replacing them with their average
03, Jan 21
Check if sum of digits of a number exceeds the product of digits of that number
13, May 21
Generate an array of maximum sum such that each element exceeds all elements present either on its left or right
03, Aug 21
Cost of rearranging the array such that no element exceeds the sum of its adjacent elements
31, Aug 20
Maximize array sum by replacing equal adjacent pairs by their sum and X respectively
21, Sep 20
Count of Binary Strings of length N such that frequency of 1's exceeds frequency of 0's
12, Aug 20
Check if Bitwise AND of concatenation of diagonals exceeds that of middle row/column elements of a Binary Matrix
06, Apr 21
Count pairs whose Bitwise AND exceeds Bitwise XOR from a given array
18, Mar 21
Count K-length subarrays whose average exceeds the median of the given array
27, Jul 21
Modify a given array by replacing each element with the sum or product of their digits based on a given condition
28, Jun 21
Maximize count of equal numbers in Array of numbers upto N by replacing pairs with their sum
28, Aug 20
Maximize sum of squares of array elements possible by replacing pairs with their Bitwise AND and Bitwise OR
12, Oct 20
Make all array elements even by replacing any pair of array elements with their sum
21, Dec 20
Make all array elements even by replacing adjacent pair of array elements with their sum
21, Dec 20
Maximum product of the remaining pair after repeatedly replacing pairs of adjacent array elements with their sum
10, Feb 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
sallagondaavinashreddy7
@sallagondaavinashreddy7
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!