Open in App
Not now

# Implement *, – and / operations using only + arithmetic operator

• Difficulty Level : Basic
• Last Updated : 16 Feb, 2023

Given two numbers, perform multiplication, subtraction, and division operations on them, using ‘+’ arithmetic operator only.

Operations can be performed as follows:

```Subtraction :-  a - b = a + (-1)*b.
Multiplication :- a * b = a + a + a ... b times.
Division :- a / b =  continuously subtract b from a and
count how many times we can do that.```

The above steps look simple, but it is slightly challenging as we can’t even use – to subtract.

## C++

 `// CPP code to illustrate *, -, / using only ` `// '+' arithmetic operator ` `#include ` `using` `namespace` `std; ` ` `  `// Function to flip the sign using only "+" ` `// operator (It is simple with '*' allowed. ` `// We need to do a = (-1)*a ` `int` `flipSign(``int` `a) ` `{ ` `    ``int` `neg = 0; ` ` `  `    ``// If sign is + ve turn it -ve ` `    ``// and vice-versa ` `    ``int` `tmp = a < 0 ? 1 : -1; ` `    ``while` `(a != 0) ` `    ``{ ` `        ``neg += tmp; ` `        ``a += tmp; ` `    ``} ` `    ``return` `neg; ` `} ` ` `  `// Check if a and b are of different signs ` `bool` `areDifferentSign(``int` `a, ``int` `b) ` `{ ` `    ``return` `((a<0 && b> 0) || (a > 0 && b < 0)); ` `} ` ` `  `// Function to subtract two numbers ` `// by negating b and adding them ` `int` `sub(``int` `a, ``int` `b) ` `{ ` `    ``// Negating b ` `    ``return` `a + flipSign(b); ` `} ` ` `  `// Function to multiply a by b by ` `// adding a to itself b times ` `int` `mul(``int` `a, ``int` `b) ` `{ ` `    ``// because algo is faster if b 0; i--) ` `        ``sum += a; ` ` `  `    ``// Check if final sign must be -ve or + ve ` `    ``if` `(b < 0) ` `        ``sum = flipSign(sum); ` ` `  `    ``return` `sum; ` `} ` ` `  `// Function to divide a by b by counting how many ` `// times 'b' can be subtracted from 'a' before ` `// getting 0 ` `int` `division(``int` `a, ``int` `b) ` `{ ` `    ``// Raise exception if b is 0 ` `    ``if` `(b == 0) ` `        ``throw``(b); ` ` `  `    ``int` `quotient = 0, dividend; ` ` `  `    ``// Negating b to subtract from a ` `    ``int` `divisor = flipSign(``abs``(b)); ` ` `  `    ``// Subtracting divisor from dividend ` `    ``for` `(dividend = ``abs``(a); dividend >= ``abs``(divisor); ` `                                ``dividend += divisor) ` `        ``quotient++; ` ` `  `    ``// Check if a and b are of similar symbols or not ` `    ``if` `(areDifferentSign(a, b)) ` `        ``quotient = flipSign(quotient); ` `    ``return` `quotient; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``cout << ``"Subtraction is "` `<< sub(4, -2) << endl; ` `    ``cout << ``"Product is "` `<< mul(-9, 6) << endl; ` ` `  `    ``try` `    ``{ ` `        ``cout << ``"Division is "` `<< division(8, 2); ` `    ``} ` ` `  `    ``catch` `(``int` `k) ` `    ``{ ` `        ``cout << ``" Exception :- Divide by 0"``; ` `    ``} ` `    ``return` `0; ` `} `

## Java

 `// Java code to illustrate *, -, / using only  ` `// '+' arithmetic operator  ` ` `  `class` `GFG{ ` `     `  `// Function to flip the sign using only "+"  ` `// operator (It is simple with '*' allowed.  ` `// We need to do a = (-1)*a  ` `static` `int` `flipSign(``int` `a)  ` `{  ` `    ``int` `neg = ``0``;  ` ` `  `    ``// If sign is + ve turn it -ve  ` `    ``// and vice-versa  ` `    ``int` `tmp = a < ``0` `? ``1` `: -``1``;  ` `    ``while` `(a != ``0``)  ` `    ``{  ` `        ``neg += tmp;  ` `        ``a += tmp;  ` `    ``}  ` `    ``return` `neg;  ` `}  ` ` `  `// Check if a and b are of different signs  ` `static` `boolean` `areDifferentSign(``int` `a, ``int` `b)  ` `{  ` `    ``return` `((a < ``0` `&& b > ``0``) || (a > ``0` `&& b < ``0``));  ` `}  ` ` `  `// Function to subtract two numbers  ` `// by negating b and adding them  ` `static` `int` `sub(``int` `a, ``int` `b)  ` `{  ` `    ``// Negating b  ` `    ``return` `a + flipSign(b);  ` `}  ` ` `  `// Function to multiply a by b by  ` `// adding a to itself b times  ` `static` `int` `mul(``int` `a, ``int` `b)  ` `{  ` `    ``// because algo is faster if b ``0``; i--)  ` `        ``sum += a;  ` ` `  `    ``// Check if final sign must be -ve or + ve  ` `    ``if` `(b < ``0``)  ` `        ``sum = flipSign(sum);  ` ` `  `    ``return` `sum;  ` `}  ` ` `  `// Function to divide a by b by counting   ` `// how many times 'b' can be subtracted   ` `// from 'a' before getting 0  ` `static` `int` `division(``int` `a, ``int` `b)  ` `{  ` `    ``// Raise exception if b is 0  ` `    ``if` `(b == ``0``)  ` `        ``throw` `new` `ArithmeticException();  ` ` `  `    ``int` `quotient = ``0``, dividend;  ` ` `  `    ``// Negating b to subtract from a  ` `    ``int` `divisor = flipSign(Math.abs(b));  ` ` `  `    ``// Subtracting divisor from dividend  ` `    ``for` `(dividend = Math.abs(a); dividend >= Math.abs(divisor);  ` `         ``dividend += divisor)  ` `        ``quotient++;  ` ` `  `    ``// Check if a and b are of similar symbols or not  ` `    ``if` `(areDifferentSign(a, b))  ` `        ``quotient = flipSign(quotient);  ` `    ``return` `quotient;  ` `}  ` ` `  `// Driver code  ` `public` `static` `void` `main(String[] args)  ` `{  ` `    ``System.out.println(``"Subtraction is "` `+ sub(``4``, -``2``));  ` `    ``System.out.println(``"Product is "` `+ mul(-``9``, ``6``));  ` ` `  `    ``try` `    ``{  ` `        ``System.out.println(``"Division is "` `+ division(``8``, ``2``));  ` `    ``}  ` ` `  `    ``catch` `(ArithmeticException e)  ` `    ``{  ` `        ``System.out.println(``"Exception :- Divide by 0"``);  ` `    ``}  ` `}  ` `} ` ` `  `// This code is contributed by mits `

## Python3

 `# Python3 code to illustrate *, -, / using  ` `# only  '+' arithmetic operator  ` ` `  `# Function to flip the sign using only "+"  ` `# operator (It is simple with '*' allowed.  ` `# We need to do a = (-1)*a  ` `def` `flipSign(a):  ` ` `  `    ``neg ``=` `0``;  ` ` `  `    ``# If sign is + ve turn it -ve  ` `    ``# and vice-versa  ` `    ``tmp ``=` `1` `if` `a < ``0` `else` `-``1``;  ` `    ``while` `(a !``=` `0``):  ` `        ``neg ``+``=` `tmp;  ` `        ``a ``+``=` `tmp;  ` ` `  `    ``return` `neg;  ` ` `  `# Check if a and b are of different signs  ` `def` `areDifferentSign(a, b): ` `    ``return` `((a < ``0` `and` `b > ``0``) ``or`  `            ``(a > ``0` `and` `b < ``0``));  ` ` `  `# Function to subtract two numbers  ` `# by negating b and adding them  ` `def` `sub(a, b):  ` ` `  `    ``# Negating b  ` `    ``return` `a ``+` `flipSign(b);  ` ` `  `# Function to multiply a by b by  ` `# adding a to itself b times  ` `def` `mul(a, b):  ` ` `  `    ``# because algo is faster if b

## C#

 `// C# code to illustrate *, -, / using only  ` `// '+' arithmetic operator  ` `using` `System; ` `class` `GFG ` `{ ` `// Function to flip the sign using only "+"  ` `// operator (It is simple with '*' allowed.  ` `// We need to do a = (-1)*a  ` `static` `int` `flipSign(``int` `a)  ` `{  ` `    ``int` `neg = 0;  ` ` `  `    ``// If sign is + ve turn it -ve  ` `    ``// and vice-versa  ` `    ``int` `tmp = a < 0 ? 1 : -1;  ` `    ``while` `(a != 0)  ` `    ``{  ` `        ``neg += tmp;  ` `        ``a += tmp;  ` `    ``}  ` `    ``return` `neg;  ` `}  ` ` `  `// Check if a and b are of different signs  ` `static` `bool` `areDifferentSign(``int` `a, ``int` `b)  ` `{  ` `    ``return` `((a < 0 && b > 0) || (a > 0 && b < 0));  ` `}  ` ` `  `// Function to subtract two numbers  ` `// by negating b and adding them  ` `static` `int` `sub(``int` `a, ``int` `b)  ` `{  ` `    ``// Negating b  ` `    ``return` `a + flipSign(b);  ` `}  ` ` `  `// Function to multiply a by b by  ` `// adding a to itself b times  ` `static` `int` `mul(``int` `a, ``int` `b)  ` `{  ` `    ``// because algo is faster if b 0; i--)  ` `        ``sum += a;  ` ` `  `    ``// Check if final sign must be -ve or + ve  ` `    ``if` `(b < 0)  ` `        ``sum = flipSign(sum);  ` ` `  `    ``return` `sum;  ` `}  ` ` `  `// Function to divide a by b by counting how many  ` `// times 'b' can be subtracted from 'a' before  ` `// getting 0  ` `static` `int` `division(``int` `a, ``int` `b)  ` `{  ` `    ``// Raise exception if b is 0  ` `    ``if` `(b == 0)  ` `        ``throw` `new` `ArithmeticException();  ` ` `  `    ``int` `quotient = 0, dividend;  ` ` `  `    ``// Negating b to subtract from a  ` `    ``int` `divisor = flipSign(Math.Abs(b));  ` ` `  `    ``// Subtracting divisor from dividend  ` `    ``for` `(dividend = Math.Abs(a); dividend >= Math.Abs(divisor);  ` `                                ``dividend += divisor)  ` `        ``quotient++;  ` ` `  `    ``// Check if a and b are of similar symbols or not  ` `    ``if` `(areDifferentSign(a, b))  ` `        ``quotient = flipSign(quotient);  ` `    ``return` `quotient;  ` `}  ` ` `  `// Driver code  ` `public` `static` `void` `Main()  ` `{  ` `    ``Console.WriteLine(``"Subtraction is "` `+ sub(4, -2));  ` `    ``Console.WriteLine(``"Product is "` `+ mul(-9, 6));  ` `    ``try` `    ``{  ` `        ``Console.WriteLine(``"Division is "` `+ division(8, 2));  ` `    ``}  ` `    ``catch` `(Exception)  ` `    ``{  ` `        ``Console.WriteLine(``"Exception :- Divide by 0"``);  ` `    ``}  ` `}  ` `} ` ` `  `//This code is contributed by mits `

## PHP

 ` 0) ||  ` `            ``(``\$a` `> 0 && ``\$b` `< 0));  ` `}  ` ` `  `// Function to subtract two numbers  ` `// by negating b and adding them  ` `function` `sub(``\$a``, ``\$b``)  ` `{  ` `    ``// Negating b  ` `    ``return` `\$a` `+ flipSign(``\$b``);  ` `}  ` ` `  `// Function to multiply a by b by  ` `// adding a to itself b times  ` `function` `mul(``\$a``, ``\$b``)  ` `{  ` `    ``// because algo is faster if b 0; ``\$i``--)  ` `        ``\$sum` `+= ``\$a``;  ` ` `  `    ``// Check if final sign must be  ` `    ``// -ve or + ve  ` `    ``if` `(``\$b` `< 0)  ` `        ``\$sum` `= flipSign(``\$sum``);  ` ` `  `    ``return` `\$sum``;  ` `}  ` ` `  `// Function to divide a by b by counting  ` `// how many times 'b' can be subtracted  ` `// from 'a' before getting 0  ` `function` `division(``\$a``, ``\$b``)  ` `{ ` `    ``\$quotient` `= 0;  ` ` `  `    ``// Negating b to subtract from a  ` `    ``\$divisor` `= flipSign(``abs``(``\$b``));  ` ` `  `    ``// Subtracting divisor from dividend  ` `    ``for` `(``\$dividend` `= ``abs``(``\$a``); ` `         ``\$dividend` `>= ``abs``(``\$divisor``);  ` `         ``\$dividend` `+= ``\$divisor``)  ` `        ``\$quotient``++;  ` ` `  `    ``// Check if a and b are of similar ` `    ``// symbols or not  ` `    ``if` `(areDifferentSign(``\$a``, ``\$b``))  ` `        ``\$quotient` `= flipSign(``\$quotient``);  ` `    ``return` `\$quotient``;  ` `}  ` ` `  `// Driver code  ` `print``(``"Subtraction is "` `. sub(4, -2) . ``"\n"``);  ` `print``(``"Product is "` `. mul(-9, 6) . ``"\n"``); ` `list(``\$a``, ``\$b``) = ``array``(8, 2); ` `if``(``\$b``) ` `    ``print``(``"Division is "` `. division(``\$a``, ``\$b``)); ` `else` `    ``print``(``"Exception :- Divide by 0"``);  ` ` `  `// This code is contributed by mits ` `?> `

## Javascript

 ` `

Output:

```Subtraction is 6
Product is -54
Division is 4```

Related Articles :

This article is contributed by Sakshi Tiwari. If you like GeeksforGeeks (We know you do!) and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

My Personal Notes arrow_drop_up
Related Articles