 GeeksforGeeks App
Open App Browser
Continue

# Efficient way to multiply with 7

Given a number n, find the result after multiplying it by 7.

Example:

Input: n=8
Output: 56

Naive Approach: The basic way to solve this is to use a multiplication operator, add the number 7 times or use recursive function.

## C++

 `#include ` `using` `namespace` `std;``// c++ implementation``long` `multiplyBySeven(``long` `n) { ``return` `(n * 7); }` `/* Driver program to test above function */``int` `main()``{``    ``long` `n = 4;` `    ``cout << multiplyBySeven(n);` `    ``return` `0;``}`

## Java

 `// Java implementation``import` `java.io.*;` `class` `GFG {``    ` `    ``static` `long` `multiplyBySeven(``long` `n) { ``return` `(n * ``7``); }``    ` `    ``/* Driver program to test above function */``    ``public` `static` `void` `main (String[] args) {``        ` `        ``long` `n = ``4``;``        ` `        ``System.out.println(multiplyBySeven(n));``        ` `    ``}``}` `// This code is contributed by Aman Kumar`

## C#

 `// C# implementation``using` `System;` `public` `class` `GFG{``    ` `    ``static` `long` `multiplyBySeven(``long` `n) { ``return` `(n * 7); }``    ` `    ``/* Driver program to test above function */``    ``static` `public` `void` `Main (){``        ``long` `n = 4;` `        ``Console.Write(multiplyBySeven(n));``    ``}``}` `// This code is contributed by Pushpesh Raj.`

## Python3

 `def` `multiplyBySeven(n: ``int``) ``-``> ``int``:``    ``return` `n ``*` `7` `n ``=` `4``print``(multiplyBySeven(n))`

## PHP

 ``

## Javascript

 ``

Output

`28`

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

Efficient Approach: We can multiply a number by 7 using a bitwise operator.

• First left shift the number by 3 bits (you will get 8n)
• Then subtract the original number from the shifted number
• Return the difference (8n – n).

Below is the implementation of the above approach:

## C

 `# include` `int` `multiplyBySeven(unsigned ``int` `n)``{ ``    ``/* Note the inner bracket here. This is needed``       ``because precedence of '-' operator is higher``       ``than '<<' */``    ``return` `((n<<3) - n);``}` `/* Driver program to test above function */``int` `main()``{``    ``unsigned ``int` `n = 4;``    ``printf``(``"%u"``, multiplyBySeven(n));` `    ``getchar``();``    ``return` `0;``}`

## CPP

 `# include` `using` `namespace` `std;`` ``//c++ implementation ``long` `multiplyBySeven(``long` `n)``{  ``    ``/* Note the inner bracket here. This is needed ``       ``because precedence of '-' operator is higher ``       ``than '<<' */``    ``return` `((n<<3) - n);``}``  ` `/* Driver program to test above function */``int` `main()``{``    ``long` `n = 4;``    ` `    ``cout<

## Java

 `// Java program to multiply any``// positive number to 7` `class` `GFG {``    ` `    ``static` `int` `multiplyBySeven(``int` `n)``    ``{``        ``/* Note the inner bracket here.``        ``This is needed because precedence``        ``of '-' operator is higher``        ``than '<<' */``        ``return` `((n << ``3``) - n);``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `main (String arg[])``    ``{``        ``int` `n = ``4``;``        ` `        ``System.out.println(multiplyBySeven(n));``    ``}``}` `// This code is contributed by Anant Agarwal.`

## Python3

 `# Python program to multiply any``# positive number to 7` `# Function to multiply any number with 7``def` `multiplyBySeven(n):` `    ``# Note the inner bracket here.``    ``# This is needed because``    ``# precedence of '-' operator is``    ``# higher than '<<'``    ``return` `((n << ``3``) ``-` `n)` `# Driver code``n ``=` `4``print``(multiplyBySeven(n))` `# This code is contributed by Danish Raza`

## C#

 `// C# program to multiply any``// positive number to 7``using` `System;` `class` `GFG``{``    ``static` `int` `multiplyBySeven(``int` `n)``    ``{``        ``/* Note the inner bracket here. This is needed``        ``because precedence of '-' operator is higher``        ``than '<<' */``        ``return` `((n << 3) - n);``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `Main ()``    ``{``        ``int` `n = 4;``        ``Console.Write(multiplyBySeven(n));``    ``}``}` `// This code is contributed by Sam007`

## PHP

 ``

## Javascript

 ``

Output

`28`

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

### Method 3:

1. We know that 7 can be represented as 2^3 – 1, which means that 7 can be expressed as (2^3) – 1.
2. So, we can write the multiplication of a number by 7 as:
7*n = (2^3 – 1)*n = (2^3)*n – n = (n << 3) – n
3. Here, << operator is used for left shift operation by 3 bits, which is equivalent to multiplying by 2^3.
We can further simplify the above expression as:
7*n = (n << 3) – n = (n << 2 + n << 1 + n)
Here, << operator is used for left shift operation by 1 bit, which is equivalent to multiplying by 2.

## C++

 `#include ` `using` `namespace` `std;` `int` `multiplyBy7(``int` `num) {``    ``return` `(num << 2) + (num << 1) + num;``}` `int` `main() {``    ``int` `n = 4;``    ``cout << multiplyBy7(n) << endl; ``// Output: 28``    ``return` `0;``}`

## Java

 `public` `class` `GFG {``    ``public` `static` `int` `multiplyBy7(``int` `num) {``        ``return` `(num << ``2``) + (num << ``1``) + num;``    ``}` `    ``public` `static` `void` `main(String[] args) {``        ``int` `n = ``4``;``        ``System.out.println(multiplyBy7(n)); ``// Output: 28``    ``}``}`

## Python3

 `def` `multiply_by_7(num):``    ``return` `(num << ``2``) ``+` `(num << ``1``) ``+` `num``#Driver code``n ``=` `4``print``(multiply_by_7(n))`

## C#

 `using` `System;` `namespace` `MultiplyBy7 {``    ``class` `Program {``        ``static` `int` `MultiplyBy7(``int` `num) {``            ``return` `(num << 2) + (num << 1) + num;``        ``}` `        ``static` `void` `Main(``string``[] args) {``            ``int` `n = 4;``            ``Console.WriteLine(MultiplyBy7(n)); ``// Output: 28``        ``}``    ``}``}`

## Javascript

 `function` `multiplyBy7(num) {``  ``return` `(num << 2) + (num << 1) + num;``}` `let n = 4;``console.log(multiplyBy7(n)); ``// Output: 28`

Output

`28`

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

Note: Works only for positive integers.
Same concept can be used for fast multiplication by 9 or other numbers.

My Personal Notes arrow_drop_up