Open In App

Program to Subtract two integers of given base

Improve
Improve
Like Article
Like
Save
Share
Report

Given three positive integers X, Y, and B, where X and Y are Base-B integers, the task is to find the value of X – Y such that X >= Y.

Examples:

Input: X = 1212, Y = 256, B = 8
Output: 0734
Explanation: The value of 1212 – 256 in base 8 is 734.

Input: X = 546, Y = 248, B = 9
Output: 287

 

Approach: The given problem can be solved by using basic mathematics subtraction. Follow the steps below to solve the given problem:

  • Initialize two variables say power = 1, carry = 0, to keep track of current power and carry generated while subtracting respectively.
  • Initialize a variable, say finalVal = 0, to store the resultant value of X – Y.
  • Iterate a loop until X > 0 and perform the following steps:
    • Store last digits from the current value of X and Y in two variables, say n1 = X % 10 and n2 = Y % 10 respectively.
    • Remove last digits from X and Y by updating X = X / 10 and Y = Y / 10.
    • Initialize temp = n1 – n2 + carry.
    • If temp < 0, then add base B to N, that is N = N + B and set carry = -1, which will act as a borrow. Otherwise, set carry = 0.
    • Add current temp * power to finalVal, that is finalVal = finalVal + temp * power and set power = power * 10.
  • After completing the above steps, print the value of finalVal as the result.

Below is the implementation of the above approach: 

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find X - Y in base B
int getDifference(int B, int X, int Y)
{
 
    // To store final answer
    int finalVal = 0;
 
    // To store carry generated
    int carry = 0;
 
    // To keep track of power
    int power = 1;
 
    while (X > 0) {
 
        // Store last digits of current
        // value of X and Y in n1 and
        // n2 respectively
        int n1 = X % 10;
        int n2 = Y % 10;
 
        // Remove last digits from
        // X and Y
        X = X / 10;
        Y = Y / 10;
 
        int temp = n1 - n2 + carry;
 
        if (temp < 0) {
 
            // Carry = -1 will act
            // as borrow
            carry = -1;
            temp += B;
        }
 
        else {
            carry = 0;
        }
 
        // Add in final result
        finalVal += temp * power;
        power = power * 10;
    }
 
    // Return final result
    return finalVal;
}
 
// Driver Code
int main()
{
    int X = 1212;
    int Y = 256;
    int B = 8;
 
    cout << (getDifference(B, X, Y));
 
    return 0;
}
 
    // This code is contributed by rakeshsahni


Java




// Java program for the above approach
import java.io.*;
 
class GFG {
 
    // Function to find X - Y in base B
    public static int getDifference(
        int B, int X, int Y)
    {
 
        // To store final answer
        int finalVal = 0;
 
        // To store carry generated
        int carry = 0;
 
        // To keep track of power
        int power = 1;
 
        while (X > 0) {
 
            // Store last digits of current
            // value of X and Y in n1 and
            // n2 respectively
            int n1 = X % 10;
            int n2 = Y % 10;
 
            // Remove last digits from
            // X and Y
            X = X / 10;
            Y = Y / 10;
 
            int temp = n1 - n2 + carry;
 
            if (temp < 0) {
 
                // Carry = -1 will act
                // as borrow
                carry = -1;
                temp += B;
            }
 
            else {
                carry = 0;
            }
 
            // Add in final result
            finalVal += temp * power;
            power = power * 10;
        }
 
        // Return final result
        return finalVal;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int X = 1212;
        int Y = 256;
        int B = 8;
 
        System.out.println(
            getDifference(B, X, Y));
    }
}


Python3




# Python3 program for the above approach
 
# Function to find X - Y in base B
def getDifference(B, X, Y) :
 
    # To store final answer
    finalVal = 0;
 
    # To store carry generated
    carry = 0;
 
    # To keep track of power
    power = 1;
 
    while (X > 0) :
 
        # Store last digits of current
        # value of X and Y in n1 and
        # n2 respectively
        n1 = X % 10;
        n2 = Y % 10;
 
        # Remove last digits from
        # X and Y
        X = X // 10;
        Y = Y // 10;
 
        temp = n1 - n2 + carry;
 
        if (temp < 0) :
 
            # Carry = -1 will act
            # as borrow
            carry = -1;
            temp += B;
 
        else :
            carry = 0;
 
        # Add in final result
        finalVal += temp * power;
        power = power * 10;
 
    # Return final result
    return finalVal;
 
# Driver Code
if __name__ == "__main__" :
 
    X = 1212;
    Y = 256;
    B = 8;
 
    print(getDifference(B, X, Y));
 
    # This code is contributed by AnkThon


C#




// C# program for the above approach
using System;
public class GFG
{
 
    // Function to find X - Y in base B
    public static int getDifference(int B, int X, int Y)
    {
 
        // To store final answer
        int finalVal = 0;
 
        // To store carry generated
        int carry = 0;
 
        // To keep track of power
        int power = 1;
 
        while (X > 0) {
 
            // Store last digits of current
            // value of X and Y in n1 and
            // n2 respectively
            int n1 = X % 10;
            int n2 = Y % 10;
 
            // Remove last digits from
            // X and Y
            X = X / 10;
            Y = Y / 10;
 
            int temp = n1 - n2 + carry;
 
            if (temp < 0) {
 
                // Carry = -1 will act
                // as borrow
                carry = -1;
                temp += B;
            }
 
            else {
                carry = 0;
            }
 
            // Add in final result
            finalVal += temp * power;
            power = power * 10;
        }
 
        // Return final result
        return finalVal;
    }
 
    // Driver Code
    public static void Main(string[] args)
    {
        int X = 1212;
        int Y = 256;
        int B = 8;
 
        Console.WriteLine(getDifference(B, X, Y));
    }
}
 
// This code is contributed by AnkThon


Javascript




<script>
// Javascript program for the above approach
 
// Function to find X - Y in base B
function getDifference(B, X, Y) {
  // To store final answer
  let finalVal = 0;
 
  // To store carry generated
  let carry = 0;
 
  // To keep track of power
  let power = 1;
 
  while (X > 0) {
    // Store last digits of current
    // value of X and Y in n1 and
    // n2 respectively
    let n1 = X % 10;
    let n2 = Y % 10;
 
    // Remove last digits from
    // X and Y
    X = Math.floor(X / 10);
    Y = Math.floor(Y / 10);
 
    let temp = n1 - n2 + carry;
 
    if (temp < 0) {
      // Carry = -1 will act
      // as borrow
      carry = -1;
      temp += B;
    } else {
      carry = 0;
    }
 
    // Add in final result
    finalVal += temp * power;
    power = power * 10;
  }
 
  // Return final result
  return finalVal;
}
 
// Driver Code
 
let X = 1212;
let Y = 256;
let B = 8;
 
document.write(getDifference(B, X, Y));
 
// This code is contributed by gfgking
 
</script>


 
 

Output

734



 

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

However, we can optimize the solution by performing the following steps:

  1. First, convert the given numbers X and Y into decimal form.
  2. Then, find the difference between X and Y.
  3. Finally, convert the decimal difference back into the given base.

Here’s the implementation of the above approach:

C++




//C++ progarm for above approach
#include <iostream>
#include <cmath>
using namespace std;
 
// Function to convert a number in given base
// to decimal form
int toDecimal(int num, int base) {
    int res = 0, power = 1;
    while (num > 0) {
        int digit = num % 10;
        res += digit * power;
        power *= base;
        num /= 10;
    }
    return res;
}
 
// Function to convert a decimal number
// to given base form
int toBase(int num, int base) {
    int res = 0, power = 1;
    while (num > 0) {
        int digit = num % base;
        res += digit * power;
        power *= 10;
        num /= base;
    }
    return res;
}
 
// Function to find X - Y in base B
int getDifference(int B, int X, int Y)
{
    // Convert X and Y to decimal form
    int X_dec = toDecimal(X, B);
    int Y_dec = toDecimal(Y, B);
 
    // Find the difference in decimal form
    int diff_dec = X_dec - Y_dec;
 
    // Convert the difference to base B form
    int diff = toBase(diff_dec, B);
 
    // Return the difference
    return diff;
}
 
// Driver Code
int main()
{
    int X = 1212;
    int Y = 256;
    int B = 8;
 
    cout << getDifference(B, X, Y);
 
    return 0;
}


Java




//Java code for above approach
import java.lang.Math;
 
public class Main {
    // Function to convert a number in given base
    // to decimal form
    static int toDecimal(int num, int base) {
        int res = 0, power = 1;
        while (num > 0) {
            int digit = num % 10;
            res += digit * power;
            power *= base;
            num /= 10;
        }
        return res;
    }
 
    // Function to convert a decimal number
    // to given base form
    static int toBase(int num, int base) {
        int res = 0, power = 1;
        while (num > 0) {
            int digit = num % base;
            res += digit * power;
            power *= 10;
            num /= base;
        }
        return res;
    }
 
    // Function to find X - Y in base B
    static int getDifference(int B, int X, int Y) {
        // Convert X and Y to decimal form
        int X_dec = toDecimal(X, B);
        int Y_dec = toDecimal(Y, B);
 
        // Find the difference in decimal form
        int diff_dec = X_dec - Y_dec;
 
        // Convert the difference to base B form
        int diff = toBase(diff_dec, B);
 
        // Return the difference
        return diff;
    }
 
    // Driver Code
    public static void main(String[] args) {
        int X = 1212;
        int Y = 256;
        int B = 8;
 
        System.out.println(getDifference(B, X, Y));
    }
}


Python3




# Python code
 
# Function to convert a number in the given base to decimal form
def to_decimal(num, base):
    res, power = 0, 1
    while num > 0:
        digit = num % 10
        res += digit * power
        power *= base
        num //= 10
    return res
 
# Function to convert a decimal number to the given base form
def to_base(num, base):
    res, power = 0, 1
    while num > 0:
        digit = num % base
        res += digit * power
        power *= 10
        num //= base
    return res
 
# Function to find X - Y in base B
def get_difference(B, X, Y):
    # Convert X and Y to decimal form
    X_dec = to_decimal(X, B)
    Y_dec = to_decimal(Y, B)
 
    # Find the difference in decimal form
    diff_dec = X_dec - Y_dec
 
    # Convert the difference to base B form
    diff = to_base(diff_dec, B)
 
    return diff
 
# Driver Code
if __name__ == "__main__":
    X = 1212
    Y = 256
    B = 8
 
    print(get_difference(B, X, Y))


C#




using System;
 
class Program
{
    // Function to convert a number in given base
    // to decimal form
    static int ToDecimal(int num, int baseValue)
    {
        int res = 0, power = 1;
        while (num > 0)
        {
            int digit = num % 10;
            res += digit * power;
            power *= baseValue;
            num /= 10;
        }
        return res;
    }
 
    // Function to convert a decimal number
    // to given base form
    static int ToBase(int num, int baseValue)
    {
        int res = 0, power = 1;
        while (num > 0)
        {
            int digit = num % baseValue;
            res += digit * power;
            power *= 10;
            num /= baseValue;
        }
        return res;
    }
 
    // Function to find X - Y in base B
    static int GetDifference(int B, int X, int Y)
    {
        // Convert X and Y to decimal form
        int X_dec = ToDecimal(X, B);
        int Y_dec = ToDecimal(Y, B);
 
        // Find the difference in decimal form
        int diff_dec = X_dec - Y_dec;
 
        // Convert the difference to base B form
        int diff = ToBase(diff_dec, B);
 
        // Return the difference
        return diff;
    }
 
    // Driver Code
    static void Main()
    {
        int X = 1212;
        int Y = 256;
        int B = 8;
 
        Console.WriteLine(GetDifference(B, X, Y));
    }
}


Javascript




// Function to convert a number in given base to decimal form
function toDecimal(num, base) {
    let res = 0, power = 1;
    while (num > 0) {
        const digit = num % 10;
        res += digit * power;
        power *= base;
        num = Math.floor(num / 10);
    }
    return res;
}
 
// Function to convert a decimal number to given base form
function toBase(num, base) {
    let res = 0, power = 1;
    while (num > 0) {
        const digit = num % base;
        res += digit * power;
        power *= 10;
        num = Math.floor(num / base);
    }
    return res;
}
 
// Function to find X - Y in base B
function getDifference(B, X, Y) {
    // Convert X and Y to decimal form
    const X_dec = toDecimal(X, B);
    const Y_dec = toDecimal(Y, B);
 
    // Find the difference in decimal form
    const diff_dec = X_dec - Y_dec;
 
    // Convert the difference to base B form
    const diff = toBase(diff_dec, B);
 
    // Return the difference
    return diff;
}
 
// Driver Code
const X = 1212;
const Y = 256;
const B = 8;
 
console.log(getDifference(B, X, Y));


Output:

734

Time Complexity: O(log^2 N) 
Auxiliary Space: O(log N)

 



Last Updated : 02 Dec, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads