Posted on by Kalkicode
Code Bit Logic

# Efficiently multiply a number by 7

Efficiently multiplying a number by 7 can be achieved using bitwise and arithmetic operations. In this explanation, I will provide a suitable example, pseudocode, algorithm, and the resultant output. I'll also explain the time complexity of the code.

Multiplying a number by 7 can be done using traditional arithmetic multiplication, but there is a more efficient method that involves using bitwise shift operations. By understanding the binary representation of 7, we can take advantage of this knowledge to perform the multiplication in a faster way.

## Problem Statement:

Given a number 'n,' we need to find an efficient method to multiply it by 7 and display the result.

## Suitable Example

Let's consider the number 9 for this example. We want to multiply 9 by 7 efficiently.

## Standard Pseudocode:

1. Start
2. Read n // Input the number to be multiplied by 7
3. result = (n << 3) - n // Efficient multiplication by 7 using bitwise shift
4. Display "The result of", n, "multiplied by 7 is", result
5. End

## Algorithm

1. Start the program.
2. Read the value of 'n.'
3. Perform the operation (n << 3) - n. a. Left shift 'n' by 3 positions, which is equivalent to multiplying 'n' by 2^3 (i.e., 8). b. Subtract 'n' from the result obtained in step 3a. c. Store the final result in a variable called 'result.'
4. Display the result of the multiplication: "The result of [input n] multiplied by 7 is [result]."
5. End the program.

## Explanation:

Let's take the example of 'n = 9' to understand how the algorithm works.

2. Perform the operation (n << 3) - n. a. Left shift 'n' by 3 positions: 9 << 3 = 72 (binary representation: 1001000). b. Subtract 'n' from the result: 72 - 9 = 63.
3. So, the result of 9 multiplied by 7 is 63.

## Code Solution

Here given code implementation process.

// C program
// Efficiently multiply a number by 7
#include <stdio.h>

// Perform multiplication by seven
void multiplyBy7(int n)
{
// Equivalent to  n *7
printf("\n %d X 7 = %d", n, ((n << 3) - n));
}
int main(int argc, char
const *argv[])
{
// Test Cases
multiplyBy7(-3);
multiplyBy7(10);
multiplyBy7(5);
multiplyBy7(13);
return 0;
}

#### Output

-3 X 7 = -21
10 X 7 = 70
5 X 7 = 35
13 X 7 = 91
// Java program
// Efficiently multiply a number by 7
public class Multiply
{
// Perform multiplication by seven
public void multiplyBy7(int n)
{
// Same as num * 7
System.out.print("\n" + n + " X 7 = " + ((n << 3) - n));
}
public static void main(String[] args)
{
// Test Cases
}
}

#### Output

-3 X 7 = -21
10 X 7 = 70
5 X 7 = 35
13 X 7 = 91
#include <iostream>

using namespace std;
// C++ program
// Efficiently multiply a number by 7
class Multiply
{
public:
// Perform multiplication by seven
void multiplyBy7(int n)
{
// Same as num *7
cout << "\n" << n << " X 7 = " << ((n << 3) - n);
}
};
int main()
{
// Test Cases
return 0;
}

#### Output

-3 X 7 = -21
10 X 7 = 70
5 X 7 = 35
13 X 7 = 91
// Include namespace system
using System;
// C# program
// Efficiently multiply a number by 7
public class Multiply
{
// Perform multiplication by seven
public void multiplyBy7(int n)
{
// Same as num * 7
Console.Write("\n" + n + " X 7 = " + ((n << 3) - n));
}
public static void Main(String[] args)
{
// Test Cases
}
}

#### Output

-3 X 7 = -21
10 X 7 = 70
5 X 7 = 35
13 X 7 = 91
<?php
// Php program
// Efficiently multiply a number by 7
class Multiply
{
// Perform multiplication by seven
public	function multiplyBy7(\$n)
{
// Same as num * 7
echo "\n". \$n ." X 7 = ". ((\$n << 3) - \$n);
}
}

function main()
{
}
main();

#### Output

-3 X 7 = -21
10 X 7 = 70
5 X 7 = 35
13 X 7 = 91
// Node Js program
// Efficiently multiply a number by 7
class Multiply
{
// Perform multiplication by seven
multiplyBy7(n)
{
// Same as num * 7
process.stdout.write("\n" + n + " X 7 = " + ((n << 3) - n));
}
}

function main()
{
// Test Cases
}
main();

#### Output

-3 X 7 = -21
10 X 7 = 70
5 X 7 = 35
13 X 7 = 91
#  Python 3 program
#  Efficiently multiply a number by 7
class Multiply :
#  Perform multiplication by seven
def multiplyBy7(self, n) :
#  Same as num * 7
print("\n", n ," X 7 = ", ((n << 3) - n), end = "")

def main() :
#  Test Cases

if __name__ == "__main__": main()

#### Output

-3  X 7 =  -21
10  X 7 =  70
5  X 7 =  35
13  X 7 =  91
#  Ruby program
#  Efficiently multiply a number by 7
class Multiply
#  Perform multiplication by seven
def multiplyBy7(n)
#  Same as num * 7
print("\n", n ," X 7 = ", ((n << 3) - n))
end

end

def main()
#  Test Cases
end

main()

#### Output

-3 X 7 = -21
10 X 7 = 70
5 X 7 = 35
13 X 7 = 91
// Scala program
// Efficiently multiply a number by 7
class Multiply
{
// Perform multiplication by seven
def multiplyBy7(n: Int): Unit = {
// Same as num * 7
print("\n" + n + " X 7 = " + ((n << 3) - n));
}
}
object Main
{
def main(args: Array[String]): Unit = {
var task: Multiply = new Multiply();
// Test Cases
}
}

#### Output

-3 X 7 = -21
10 X 7 = 70
5 X 7 = 35
13 X 7 = 91
// Swift 4 program
// Efficiently multiply a number by 7
class Multiply
{
// Perform multiplication by seven
func multiplyBy7(_ n: Int)
{
// Same as num * 7
print( n ," X 7 = ", ((n << 3) - n));
}
}
func main()
{
// Test Cases
}
main();

#### Output

-3  X 7 =  -21
10  X 7 =  70
5  X 7 =  35
13  X 7 =  91
// Kotlin program
// Efficiently multiply a number by 7
class Multiply
{
// Perform multiplication by seven
fun multiplyBy7(n: Int): Unit
{
// Same as num * 7
print("\n" + n + " X 7 = " + ((n shl 3) - n));
}
}
fun main(args: Array < String > ): Unit
{
// Test Cases
}

#### Output

-3 X 7 = -21
10 X 7 = 70
5 X 7 = 35
13 X 7 = 91

These results are consistent with the algorithm. For example, taking '-3' as input, the algorithm follows the steps:

1. Left shift '-3' by 3 positions: -3 << 3 = -24.
2. Subtract '-3' from the result: -24 - (-3) = -21.
3. So, the result of '-3' multiplied by 7 is -21.

## Time Complexity

The time complexity of the given algorithm is constant (O(1)). It doesn't depend on the input size and will execute in a constant amount of time regardless of the value of 'n'. The algorithm involves only a few bitwise and arithmetic operations, so its execution time is very efficient and constant for any input.

## Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

Categories
Relative Post