Open In App

# Program to Subtract two integers of given base

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 ``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

 ``

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 ``#include ``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));``    ``}``}`

Output:

`734`

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