Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Compare two floating-point numbers given in Scientific Notations

  • Difficulty Level : Easy
  • Last Updated : 21 Feb, 2022

Given two strings N and M in the form of a * 10 b. The task is to compare given two floating-point numbers and print the smaller number and if both the numbers are equal then print Equal. 

 0<|a|<10^9  and  -10^9<b<10^9.

Example:

N and M are two numbers with two parts:

  1. a1 is mantissa of N and a2 is mantissa of M.
  2. b1 is exponent of N and b2 is exponent of M.

Input: N = 3*10^2, M = 299*10^0
Output: M
Explanation: 
a1 = 3, b1 = 2
a2 = 299, b2 = 0
N = 3*10^2 = 300 
M = 299*10^0 = 299. 
We know that 299 is smaller than 300.

Input: N = -5*10^3, M =  -50*10^2
Output : Equal 
Explanation:  
a1 = -5, b1 = 3
a2 = -50, b2 = 2
N = -5*10^3 = -5000
M = -50*10^2 = -5000
Hence, N and M are equal.

Input: N  = -2*10^1, M = -3*10^1
Output: M
Explanation:
a1 = -2 , b1 = 1
a2 = -3 , b2 = 1
N = -20
M = -30
-30 is less than -20, hence M is smaller number.

Naive Approach: We will calculate the values of numbers extracted from strings N and M and then compare which one is better. The bigInteger class will be used for storing and calculating the value of N and M in Java. This approach can give Time Limit Exceeded error for larger test cases.

Optimal Approach:  

  • Extract mantissa and exponents from both the strings N and M.
  • Find the index of ‘*’ ( let say mulInd), then substring before mulInd will be mantissa(a1).
  • Find the index of ‘^’, let say powInd, then substring after powInd will be exponent(b1).
  • Similarly, find out a2 and b2.
  • if(a1 > 0 && a2 < 0), print M ( M will always be smaller).
  • Similarly, if (a2 > 0 && a1 < 0), print N.
  • else there will be need to use log to compare.
  • The following formula will be used to calculate the log and arrive at a result that will be compared to determine which number is larger. 
     

N = a1 * 10 ^ b1

Taking log base 10 both side

log N = log(a1) + b1                ———-(1)

Similarly, log(M) = log(a2) + b2 ———(2)

Subtract equation (1) from equation (2)
     ans = (2) – (1)
     ans = log(a1/a2) + b1 – b2

Therefore: int ans = log(a1/a2) + b1 – b2

  • if a1 < 0, then ans  = -ans. This is because both a1 and a2 are both negative.
    • if ans < 0, print N.
    • else if ans > 0, print M.
  • else print Equal.

Below is the Jave program to implement the above approach:

Java




// Java program to implement
// the above approach
import java.io.*;
import java.util.*;
import java.math.*;
import java.lang.*;
 
class GFG
{
  // Function to extract mantissa
  static int[] extract_mantissa(String N,
                                String M)
  {
    int mantissa[] = new int [2];
    int mulInd1 = N.indexOf('*');
    int a1 = Integer.parseInt(
             N.substring(0, mulInd1));
    mantissa[0] = a1;
              
    int mulInd2 = M.indexOf('*');
    int a2 = Integer.parseInt(
             M.substring(0, mulInd2));
    mantissa[1] = a2;
    return mantissa;
  }
   
  // Function to extract exponent
  static int[] extract_exponent(String N,
                                String M)
  {
    int exponent[] = new int [2];
    int powInd1 = N.indexOf('^');
    int b1 = Integer.parseInt(
             N.substring(powInd1 + 1));
    exponent[0] = b1;
              
    int powInd2 = M.indexOf('^');        
    int b2 = Integer.parseInt(
             M.substring(powInd2 + 1));
    exponent[1] = b2;
    return exponent;
  }
   
  // Function to find smaller number
  static void solution(int a1, int b1,
                       int a2, int b2)
  
    double x = ((double)(a1) /
                (double)(a2));
    double ans = (b1 - b2 +
                  Math.log10(x));
     
    // If both are negative
    if(a1 < 0)
      ans = -ans;
    if(ans < 0)
      System.out.println("N");
    else if(ans > 0)
      System.out.println("M");
    else
      System.out.println("Equal");
  }
   
  static void solve(String N, String M)
  {
    // Extract mantissa(a1) and mantissa(a2)
    // from num1 and num2
    int mantissa[] = extract_mantissa(N, M);
 
    // Extract exponent(b1) and exponent(b2)
    // from num1 and num2
    int exponent[] = extract_exponent(N, M);
 
    if(mantissa[0] > 0 && mantissa[1] < 0)
      System.out.println("M");
    else if(mantissa[0] < 0 && mantissa[1] > 0)
      System.out.println("N");
    else
    {
      // if mantissa of both num1 and num2
      // are positive or both are negative
      solution(mantissa[0], exponent[0],
               mantissa[1], exponent[1]);
    }
  }
   
  // Driver code
  public static void main (String[] args)
  {
    // Mantissa is negative and
    // exponent is positive
    String N = "-5*10^3";
    String M = "-50*10^2";
    solve(N, M);
     
    // Mantissa is negative and
    // exponent is negative
    N = "-5*10^-3";
    M = "-50*10^-2";
    solve(N, M);
 
    // Mantissa is positive and
    // exponent is negative
    N = "5*10^-3";
    M = "50*10^-2";
    solve(N, M);
     
    // Mantissa is positive and
    // exponent is positive
    N = "5*10^3";
    M = "50*10^2";
    solve(N, M);
  }
}

Python3




# Python 3 program to implement
# the above approach
import math
 
# Function to extract mantissa
def extract_mantissa(N,  M):
 
    mantissa = [0]*2
    mulInd1 = list(N).index('*')
    a1 = N[0: mulInd1]
    mantissa[0] = a1
 
    mulInd2 = list(M).index('*')
    a2 = M[0: mulInd2]
    mantissa[1] = a2
    return mantissa
 
# Function to extract exponent
def extract_exponent(N,  M):
 
    exponent = [0]*2
    powInd1 = list(N).index('^')
    b1 = N[powInd1 + 1:]
    exponent[0] = b1
 
    powInd2 = list(M).index('^')
    b2 = M[powInd2 + 1:]
    exponent[1] = b2
    return exponent
 
# Function to find smaller number
def solution(a1,  b1,
             a2,  b2):
 
    x = int(a1) / int(a2)
    ans = (int(b1) - int(b2) + math.log10(x))
 
    # If both are negative
    if(int(a1) < 0):
        ans = -ans
    if(ans < 0):
        print("N")
    elif(ans > 0):
        print("M")
    else:
        print("Equal")
 
def solve(N,  M):
 
    # Extract mantissa(a1) and mantissa(a2)
    # from num1 and num2
    mantissa = extract_mantissa(N, M)
 
    # Extract exponent(b1) and exponent(b2)
    # from num1 and num2
    exponent = extract_exponent(N, M)
 
    if(int(mantissa[0]) > 0 and int(mantissa[1]) < 0):
        print("M")
    elif(int(mantissa[0]) < 0 and int(mantissa[1]) > 0):
        print("N")
    else:
 
        # if mantissa of both num1 and num2
        # are positive or both are negative
        solution(mantissa[0], exponent[0],
                 mantissa[1], exponent[1])
 
# Driver code
if __name__ == "__main__":
 
    # Mantissa is negative and
    # exponent is positive
    N = "-5*10^3"
    M = "-50*10^2"
    solve(N, M)
 
    # Mantissa is negative and
    # exponent is negative
    N = "-5*10^-3"
    M = "-50*10^-2"
    solve(N, M)
 
    # Mantissa is positive and
    # exponent is negative
    N = "5*10^-3"
    M = "50*10^-2"
    solve(N, M)
 
    # Mantissa is positive and
    # exponent is positive
    N = "5*10^3"
    M = "50*10^2"
    solve(N, M)
 
    # This code is contributed by ukasp.

C#




// C# program to implement
// the above approach
using System;
 
class GFG
{
  // Function to extract mantissa
  public static int[] extract_mantissa(String N, String M)
  {
    int[] mantissa = new int [2];
    int mulInd1 = N.IndexOf('*');
    int a1 = int.Parse(N.Substring(0, mulInd1));
    mantissa[0] = a1;
              
    int mulInd2 = M.IndexOf('*');
    int a2 = int.Parse(M.Substring(0, mulInd2));
    mantissa[1] = a2;
    return mantissa;
  }
   
  // Function to extract exponent
  public static int[] extract_exponent(String N,  String M)
  {
    int[] exponent = new int [2];
    int powInd1 = N.IndexOf('^');
    int b1 = int.Parse(N.Substring(powInd1 + 1));
    exponent[0] = b1;
              
    int powInd2 = M.IndexOf('^');        
    int b2 = int.Parse(
             M.Substring(powInd2 + 1));
    exponent[1] = b2;
    return exponent;
  }
   
  // Function to find smaller number
  static void solution(int a1, int b1,
                       int a2, int b2)
  
    double x = ((double)(a1) /
                (double)(a2));
    double ans = (b1 - b2 +
                  Math.Log10(x));
     
    // If both are negative
    if(a1 < 0)
      ans = -ans;
    if(ans < 0)
      Console.WriteLine("N");
    else if(ans > 0)
      Console.WriteLine("M");
    else
      Console.WriteLine("Equal");
  }
   
  static void solve(String N, String M)
  {
    // Extract mantissa(a1) and mantissa(a2)
    // from num1 and num2
    int[] mantissa = extract_mantissa(N, M);
 
    // Extract exponent(b1) and exponent(b2)
    // from num1 and num2
    int[] exponent = extract_exponent(N, M);
 
    if(mantissa[0] > 0 && mantissa[1] < 0)
      Console.WriteLine("M");
    else if(mantissa[0] < 0 && mantissa[1] > 0)
      Console.WriteLine("N");
    else
    {
      // if mantissa of both num1 and num2
      // are positive or both are negative
      solution(mantissa[0], exponent[0],
               mantissa[1], exponent[1]);
    }
  }
   
  // Driver code
  public static void Main ()
  {
    // Mantissa is negative and
    // exponent is positive
    String N = "-5*10^3";
    String M = "-50*10^2";
    solve(N, M);
     
    // Mantissa is negative and
    // exponent is negative
    N = "-5*10^-3";
    M = "-50*10^-2";
    solve(N, M);
 
    // Mantissa is positive and
    // exponent is negative
    N = "5*10^-3";
    M = "50*10^-2";
    solve(N, M);
     
    // Mantissa is positive and
    // exponent is positive
    N = "5*10^3";
    M = "50*10^2";
    solve(N, M);
  }
}
 
// This code is contributed by saurabh_jaiswal.

Output:

Equal
M
N
Equal

Time Complexity: O ( 1 )                                                                                                                                                                              
According to the given constraints |a| can be of a maximum of 10 lengths of string and if it is negative, then it could be of 11 lengths, similarly b can also be of 11 digits. The maximum length of string could be 25 (11 +3+11), so we can consider extracting a and b of constant time operation.

Auxiliary Space: O ( 1 )


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!