Calculate 7n/8 without using division and multiplication operators
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.
Last Updated :
28 Nov, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...