Given two numbers A and B, such that 0 <= A <= B <= (2³¹ – 1). Compute the average ((A + B) / 2) of the two numbers.

Examples:

Input: A = 1000000000, B = 2000000000
Output: 1500000000.000000
Explanation: (A + B)/2 = (1000000000+ 2000000000)/2 = 1500000000.000000

Input: A = 2000000000, B = 2000000001
Output: 2000000000.500000
Explanation: (A + B)/2 = (2000000000 + 2000000001)/2 = 2000000000.500000

Approach: To solve the problem, follow the below idea:

We know that average of two numbers A and B = (A + B) / 2 but if we try to compute the sum of A and B, it will lead to an overflow. So, we need to apply a different formula to compute the average. Since average of A and B is half of the sum of A and B. We can also compute average as (A/2) + (B/2).

Below is the implementation of the approach:

#include <iostream>
using namespace std;

// Function to compute average of two numbers
double computeAverage(int a, int b) {
    return (a / 2.0) + (b / 2.0);
}

// Driver code
int main() {
    // Assigning maximum integer value
    int a = 2000000000, b = 2000000001;

    // Function to get the average of 2 numbers
    printf("Average: %.6f", computeAverage(a, b));
    return 0;
}

#include <iostream>

using namespace std;

​

// Function to compute average of two numbers

double computeAverage(int a, int b) {

    return (a / 2.0) + (b / 2.0);

}

​

// Driver code

int main() {

    // Assigning maximum integer value

    int a = 2000000000, b = 2000000001;

​

    // Function to get the average of 2 numbers

    printf("Average: %.6f", computeAverage(a, b));

    return 0;

}

// Java code to compute
// average of two numbers
import java.io.*;

class GFG {

    // Function to compute average of two numbers
    static double computeAverage(int a, int b)
    {
        return (a / 2.0) + (b / 2.0);
    }

    // Driver code
    public static void main(String[] args)
    {
        // Assigning maximum integer value
        int a = 2000000000, b = 2000000001;

        // Function to get the average of 2 numbers
        System.out.printf("Average: %.6f", computeAverage(a, b));
    }
}

# Function to compute average of two numbers
def compute_average(a, b):
    return (a / 2.0) + (b / 2.0)

# Assigning maximum integer value
a, b = 2000000000, 2000000001

# Function to get the average of 2 numbers
print("Average: {:.6f}".format(compute_average(a, b)))

using System;

class Program
{
    // Function to compute average of two numbers
    static double ComputeAverage(int a, int b)
    {
        return (a / 2.0) + (b / 2.0);
    }

    // Driver code
    static void Main()
    {
        // Assigning maximum integer value
        int a = 2000000000, b = 2000000001;

        // Function to get the average of 2 numbers
        Console.WriteLine("Average: {0:F6}", ComputeAverage(a, b));
    }
}

// Function to compute average of two numbers
function computeAverage(a, b) {
    // Using floating-point division to ensure accurate average
    return (a / 2.0) + (b / 2.0);
}

// Main function
function main() {
    // Assigning maximum integer value
    const a = 2000000000, b = 2000000001;

    // Call the computeAverage function to get the average of two numbers
    console.log("Average:", computeAverage(a, b).toFixed(6));
}

// Call the main function to execute the program
main();

Average: 2000000000.500000

Time Complexity: O(1), the code will run in a constant time.
Auxiliary Space: O(1), no extra space is required, so it is a constant.

Approach 2:

We can also calculate the average of two numbers A and B using the formula: A + (B – A)/2.

Below is the implementation of the approach:

#include <bits/stdc++.h>
using namespace std;

// Function to compute average of two numbers
double compute_average(int a, int b)
{
    return a + (b - a) / 2.0;
}

// Driver code
int main()
{
    // Assigning maximum integer value
    int a = 2000000000, b = 2000000001;

    // Function to get the average of 2 numbers
    cout << "Average : " << fixed << compute_average(a, b)
         << endl;

    return 0;
}

#include <bits/stdc++.h>

using namespace std;

​

// Function to compute average of two numbers

double compute_average(int a, int b)

{

    return a + (b - a) / 2.0;

}

​

// Driver code

int main()

{

    // Assigning maximum integer value

    int a = 2000000000, b = 2000000001;

​

    // Function to get the average of 2 numbers

    cout << "Average : " << fixed << compute_average(a, b)

         << endl;

​

    return 0;

}

public class ComputeAverage {
    // Function to compute average of two numbers
    public static double computeAverage(int a, int b) {
        return a + (b - a) / 2.0;
    }

    // Driver code
    public static void main(String[] args) {
        // Assigning maximum integer value
        int a = 2000000000, b = 2000000001;

        // Function to get the average of 2 numbers
        double avg = computeAverage(a, b);

        // Format the output to display the double value without scientific notation
        String formattedAvg = String.format("%.2f", avg);
        System.out.println("Average : " + formattedAvg);
    }
}


// This code is contributed by shivamgupta0987654321

# Function to compute average of two numbers
def compute_average(a, b):
    return a + (b - a) / 2.0

# Driver code
def main():
    # Assigning maximum integer value
    a, b = 2000000000, 2000000001

    # Function to get the average of 2 numbers
    print("Average : {:.2f}".format(compute_average(a, b)))

# Call the main function
main()

// Function to compute average of two numbers
function computeAverage(a, b) {
    return a + (b - a) / 2.0;
}

// Driver code
function main() {
    // Assigning maximum integer value
    let a = 2000000000, b = 2000000001;

    // Function to get the average of 2 numbers
    console.log("Average : " + computeAverage(a, b).toFixed(2));
}

// Call the main function
main();

Average : 2000000000.500000

Time Complexity: O(1), the code will run in a constant time.
Auxiliary Space: O(1), no extra space is required, so it is a constant.

GeeksforGeeks

9

Improve

Article Tags :

• DSA
• Mathematical
• Nvidia

Practice Tags :

• Nvidia
• Mathematical