Calculate 7n/8 without using division and multiplication operators
Last Updated :
28 Nov, 2023
Given an integer, write a function that calculates ?7n/8? (ceiling of 7n/8) without using division and multiplication operators.
We strongly recommend to minimize your browser and try this yourself first.
Method 1:
The idea is to first calculate floor of n/8, i.e., ?n/8? using right shift bitwise operator. The expression n>>3 produces the same.
If we subtract ?n/8? from n, we get ?7n/8?
Below is the implementation of above idea :
C++
#include <iostream>
using namespace std;
int multiplyBySevenByEight( int n)
{
return (n - (n >> 3));
}
int main()
{
int n = 9;
cout << multiplyBySevenByEight(n);
return 0;
}
|
C
#include <stdio.h>
int multiplyBySevenByEight(unsigned int n)
{
return (n - (n >> 3));
}
int main()
{
unsigned int n = 9;
printf ( "%d" , multiplyBySevenByEight(n));
return 0;
}
|
Java
import java.io.*;
class GFG {
static int multiplyBySevenByEight( int n)
{
return (n - (n >> 3 ));
}
public static void main(String args[])
{
int n = 9 ;
System.out.println(multiplyBySevenByEight(n));
}
}
|
Python3
def multiplyBySevenByEight(n):
return (n - (n >> 3 ))
n = 9
print (multiplyBySevenByEight(n))
|
C#
using System;
public class GFG {
static int multiplyBySevenByEight( int n)
{
return (n - (n >> 3));
}
public static void Main()
{
int n = 9;
Console.WriteLine(multiplyBySevenByEight(n));
}
}
|
Javascript
<script>
function multiplyBySevenByEight(n)
{
return (n - (n>>3));
}
let n = 9;
document.write(multiplyBySevenByEight(n));
</script>
|
PHP
<?php
function multiplyBySevenByEight( $n )
{
return ( $n - ( $n >> 3));
}
$n = 9;
echo multiplyBySevenByEight( $n );
?>
|
Output :
8
Time Complexity: O(1)
Auxiliary Space: O(1)
Method 2 (Always matches with 7*n/8):
The above method doesn’t always produce result same as “printf(“%u”, 7*n/8)”. For example, the value of expression 7*n/8 is 13 for n = 15, but above program produces 14. Below is modified version that always matches 7*n/8. The idea is to first multiply the number with 7, then divide by 8 as it happens in expression 7*n/8.
C++
#include<iostream>
using namespace std;
int multiplyBySevenByEight(unsigned int n)
{
return ((n << 3) -n) >> 3;
}
int main()
{
unsigned int n = 15;
cout<< " " << multiplyBySevenByEight(n);
return 0;
}
|
C
#include<stdio.h>
int multiplyBySevenByEight(unsigned int n)
{
return ((n << 3) -n) >> 3;
}
int main()
{
unsigned int n = 15;
printf ( "%u" , multiplyBySevenByEight(n));
return 0;
}
|
Java
import java.io.*;
class GFG
{
static int multiplyBySevenByEight( int n)
{
return ((n << 3 ) -n) >> 3 ;
}
public static void main(String args[])
{
int n = 15 ;
System.out.println(multiplyBySevenByEight(n));
}
}
|
Python3
def multiplyBySevenByEight(n):
return ((n << 3 ) - n) >> 3 ;
n = 15 ;
print (multiplyBySevenByEight(n));
|
C#
using System;
public class GFG {
static int multiplyBySevenByEight( int n)
{
return ((n << 3) -n) >> 3;
}
public static void Main()
{
int n = 15;
Console.WriteLine(
multiplyBySevenByEight(n));
}
}
|
Javascript
<script>
function multiplyBySevenByEight(n)
{
return ((n << 3) -n) >> 3;
}
var n = 15;
document.write(multiplyBySevenByEight(n));
</script>
|
PHP
<?php
function multiplyBySevenByEight( $n )
{
return (( $n << 3) - $n ) >> 3;
}
$n = 15;
echo multiplyBySevenByEight( $n );
?>
|
Output :
13
Time Complexity: O(1)
Auxiliary Space: O(1)
Note : There is difference between outcomes of two methods. The method 1 produces ceil(7n/8), but method two produces integer value of 7n/8. For example, for n = 15, outcome of first method is 14, but for second method is 13.
Thanks to Narendra Kangralkar for suggesting this method.
Approach:
- Multiply the number n by 7 using the following steps.
- Left shift n by 3 positions (multiply n by 8).
- Subtract n from the result obtained in the previous step.
- To calculate the ceiling of 7n/8, add 7 to the result obtained in step 1.
- Right shift the result obtained in step 2 by 3 positions to divide it by 8.
Below is the implementation of this approach:
C++
#include <iostream>
using namespace std;
int calculateCeiling( int n) {
int result = ((n << 3) - n + 7) >> 3;
return result;
}
int main() {
int n = 9;
cout << calculateCeiling(n) << endl;
return 0;
}
|
Java
import java.util.*;
public class GFG {
static int calculateCeiling( int n)
{
int result = ((n << 3 ) - n + 7 ) >> 3 ;
return result;
}
public static void main(String[] args)
{
int n = 9 ;
System.out.println(calculateCeiling(n));
}
}
|
Python3
def calculateCeiling(n):
result = ((n << 3 ) - n + 7 ) >> 3
return result
if __name__ = = "__main__" :
n = 9
print (calculateCeiling(n))
|
C#
using System;
class Program
{
static int CalculateCeiling( int n)
{
int result = ((n << 3) - n + 7) >> 3;
return result;
}
static void Main( string [] args)
{
int n = 9;
Console.WriteLine(CalculateCeiling(n));
}
}
|
Javascript
function calculateCeiling(n) {
let result = ((n << 3) - n + 7) >> 3;
return result;
}
let n = 9;
document.write(calculateCeiling(n));
|
Output:
8
Time Complexity: O(1), as it only involves a few bitwise operations regardless of the input value n.
Space Complexity: O(1) since it does not require any additional space that grows with the input size.
This article is contributed by Rajeev.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...