Sum of n numbers with exactly 3 set bits

Here given code implementation process.

/*
    Java Program
    Sum of n numbers with exactly 3 set bits 
*/
public class BinaryBits
{
	public void threeActiveBits(int n)
	{
		int count = n;
		int temp = 1;
		int num = 2;
		int sum = 0;
		while (count > 0)
		{
			num = (num << 1);
			while (temp < (num >> 1) && count > 0)
			{
				sum += (num | (num >> 1) | temp);
				temp = temp << 1;
				count--;
			}
			temp = 1;
		}
		// Display number of element
		System.out.println(" Given n  : " + n);
		// Display calculate sum
		System.out.println(" Result   : " + sum);
	}
	public static void main(String[] args)
	{
		BinaryBits task = new BinaryBits();
		// Test A
		// n = 10 
		// --------------
		// 7	111
		// 13	1101
		// 14	1110
		// 25	11001
		// 26	11010
		// 28	11100
		// 49	110001
		// 50	110010
		// 52	110100
		// 56	111000
		//  [7 + 13 + 14 + 25 + 26 + 28 + 49 + 
		//   50 + 52 + 56] = 320
		task.threeActiveBits(10);
		// Test B
		// num = 20 
		// --------------
		// 7	111
		// 13	1101
		// 14	1110
		// 25	11001
		// 26	11010
		// 28	11100
		// 49	110001
		// 50	110010
		// 52	110100
		// 56	111000
		// 97	1100001
		// 98	1100010
		// 100	1100100
		// 104	1101000
		// 112	1110000
		// 193	11000001
		// 194	11000010
		// 196	11000100
		// 200	11001000
		// 208	11010000
		// [7 + 13 + 14 + 25 + 26 + 28 + 49 + 50 +
		//  52 + 56 + 97 + 98 + 100 + 104 + 112 + 
		//  193 + 194 + 196 + 200 + 208] = 1822
		task.threeActiveBits(20);
	}
}

Output

 Given n  : 10
 Result   : 320
 Given n  : 20
 Result   : 1822

// C Program for
// Sum of n numbers with exactly 3 set bits 
#include <stdio.h>

void threeActiveBits(int n)
{
	int count = n;
	int temp = 1;
	int num = 2;
	int sum = 0;
	while (count > 0)
	{
		num = (num << 1);
		while (temp < (num >> 1) && count > 0)
		{
			sum += (num | (num >> 1) | temp);
			temp = temp << 1;
			count--;
		}
		temp = 1;
	}
	// Display number of element
	printf(" Given n  : %d\n", n);
	// Display calculate sum
	printf(" Result   : %d\n", sum);
}
int main(int argc, char
	const *argv[])
{
	// Test A
	// n = 10 
	// --------------
	// 7	111
	// 13	1101
	// 14	1110
	// 25	11001
	// 26	11010
	// 28	11100
	// 49	110001
	// 50	110010
	// 52	110100
	// 56	111000
	//  [7 + 13 + 14 + 25 + 26 + 28 + 49 + 
	//   50 + 52 + 56] = 320
	threeActiveBits(10);
	// Test B
	// num = 20 
	// --------------
	// 7	111
	// 13	1101
	// 14	1110
	// 25	11001
	// 26	11010
	// 28	11100
	// 49	110001
	// 50	110010
	// 52	110100
	// 56	111000
	// 97	1100001
	// 98	1100010
	// 100	1100100
	// 104	1101000
	// 112	1110000
	// 193	11000001
	// 194	11000010
	// 196	11000100
	// 200	11001000
	// 208	11010000
	// [7 + 13 + 14 + 25 + 26 + 28 + 49 + 50 +
	//  52 + 56 + 97 + 98 + 100 + 104 + 112 + 
	//  193 + 194 + 196 + 200 + 208] = 1822
	threeActiveBits(20);
	return 0;
}

Output

 Given n  : 10
 Result   : 320
 Given n  : 20
 Result   : 1822

// Include header file
#include <iostream>
using namespace std;
/*
    C++ Program
    Sum of n numbers with exactly 3 set bits 
*/
class BinaryBits
{
	public: void threeActiveBits(int n)
	{
		int count = n;
		int temp = 1;
		int num = 2;
		int sum = 0;
		while (count > 0)
		{
			num = (num << 1);
			while (temp < (num >> 1) && count > 0)
			{
				sum += (num | (num >> 1) | temp);
				temp = temp << 1;
				count--;
			}
			temp = 1;
		}
		// Display number of element
		cout << " Given n  : " << n << endl;
		// Display calculate sum
		cout << " Result   : " << sum << endl;
	}
};
int main()
{
	BinaryBits *task = new BinaryBits();
	// Test A
	// n = 10 
	// --------------
	// 7	111
	// 13	1101
	// 14	1110
	// 25	11001
	// 26	11010
	// 28	11100
	// 49	110001
	// 50	110010
	// 52	110100
	// 56	111000
	//  [7 + 13 + 14 + 25 + 26 + 28 + 49 + 
	//   50 + 52 + 56] = 320
	task->threeActiveBits(10);
	// Test B
	// num = 20 
	// --------------
	// 7	111
	// 13	1101
	// 14	1110
	// 25	11001
	// 26	11010
	// 28	11100
	// 49	110001
	// 50	110010
	// 52	110100
	// 56	111000
	// 97	1100001
	// 98	1100010
	// 100	1100100
	// 104	1101000
	// 112	1110000
	// 193	11000001
	// 194	11000010
	// 196	11000100
	// 200	11001000
	// 208	11010000
	// [7 + 13 + 14 + 25 + 26 + 28 + 49 + 50 +
	//  52 + 56 + 97 + 98 + 100 + 104 + 112 + 
	//  193 + 194 + 196 + 200 + 208] = 1822
	task->threeActiveBits(20);
	return 0;
}

Output

 Given n  : 10
 Result   : 320
 Given n  : 20
 Result   : 1822

// Include namespace system
using System;
/*
    Csharp Program
    Sum of n numbers with exactly 3 set bits 
*/
public class BinaryBits
{
	public void threeActiveBits(int n)
	{
		int count = n;
		int temp = 1;
		int num = 2;
		int sum = 0;
		while (count > 0)
		{
			num = (num << 1);
			while (temp < (num >> 1) && count > 0)
			{
				sum += (num | (num >> 1) | temp);
				temp = temp << 1;
				count--;
			}
			temp = 1;
		}
		// Display number of element
		Console.WriteLine(" Given n  : " + n);
		// Display calculate sum
		Console.WriteLine(" Result   : " + sum);
	}
	public static void Main(String[] args)
	{
		BinaryBits task = new BinaryBits();
		// Test A
		// n = 10 
		// --------------
		// 7	111
		// 13	1101
		// 14	1110
		// 25	11001
		// 26	11010
		// 28	11100
		// 49	110001
		// 50	110010
		// 52	110100
		// 56	111000
		//  [7 + 13 + 14 + 25 + 26 + 28 + 49 + 
		//   50 + 52 + 56] = 320
		task.threeActiveBits(10);
		// Test B
		// num = 20 
		// --------------
		// 7	111
		// 13	1101
		// 14	1110
		// 25	11001
		// 26	11010
		// 28	11100
		// 49	110001
		// 50	110010
		// 52	110100
		// 56	111000
		// 97	1100001
		// 98	1100010
		// 100	1100100
		// 104	1101000
		// 112	1110000
		// 193	11000001
		// 194	11000010
		// 196	11000100
		// 200	11001000
		// 208	11010000
		// [7 + 13 + 14 + 25 + 26 + 28 + 49 + 50 +
		//  52 + 56 + 97 + 98 + 100 + 104 + 112 + 
		//  193 + 194 + 196 + 200 + 208] = 1822
		task.threeActiveBits(20);
	}
}

Output

 Given n  : 10
 Result   : 320
 Given n  : 20
 Result   : 1822

package main
import "fmt"
/*
    Go Program
    Sum of n numbers with exactly 3 set bits 
*/
type BinaryBits struct {}
func getBinaryBits() * BinaryBits {
	var me *BinaryBits = &BinaryBits {}
	return me
}
func(this BinaryBits) threeActiveBits(n int) {
	var count int = n
	var temp int = 1
	var num int = 2
	var sum int = 0
	for (count > 0) {
		num = (num << 1)
		for (temp < (num >> 1) && count > 0) {
			sum += (num | (num >> 1) | temp)
			temp = temp << 1
			count--
		}
		temp = 1
	}
	// Display number of element
	fmt.Println(" Given n  : ", n)
	// Display calculate sum
	fmt.Println(" Result   : ", sum)
}
func main() {
	var task * BinaryBits = getBinaryBits()
	// Test A
	// n = 10 
	// --------------
	// 7	111
	// 13	1101
	// 14	1110
	// 25	11001
	// 26	11010
	// 28	11100
	// 49	110001
	// 50	110010
	// 52	110100
	// 56	111000
	//  [7 + 13 + 14 + 25 + 26 + 28 + 49 + 
	//   50 + 52 + 56] = 320
	task.threeActiveBits(10)
	// Test B
	// num = 20 
	// --------------
	// 7	111
	// 13	1101
	// 14	1110
	// 25	11001
	// 26	11010
	// 28	11100
	// 49	110001
	// 50	110010
	// 52	110100
	// 56	111000
	// 97	1100001
	// 98	1100010
	// 100	1100100
	// 104	1101000
	// 112	1110000
	// 193	11000001
	// 194	11000010
	// 196	11000100
	// 200	11001000
	// 208	11010000
	// [7 + 13 + 14 + 25 + 26 + 28 + 49 + 50 +
	//  52 + 56 + 97 + 98 + 100 + 104 + 112 + 
	//  193 + 194 + 196 + 200 + 208] = 1822
	task.threeActiveBits(20)
}

Output

 Given n  : 10
 Result   : 320
 Given n  : 20
 Result   : 1822

<?php
/*
    Php Program
    Sum of n numbers with exactly 3 set bits 
*/
class BinaryBits
{
	public	function threeActiveBits($n)
	{
		$count = $n;
		$temp = 1;
		$num = 2;
		$sum = 0;
		while ($count > 0)
		{
			$num = ($num << 1);
			while ($temp < ($num >> 1) && $count > 0)
			{
				$sum += ($num | ($num >> 1) | $temp);
				$temp = $temp << 1;
				$count--;
			}
			$temp = 1;
		}
		// Display number of element
		echo(" Given n  : ".$n."\n");
		// Display calculate sum
		echo(" Result   : ".$sum."\n");
	}
}

function main()
{
	$task = new BinaryBits();
	// Test A
	// n = 10 
	// --------------
	// 7	111
	// 13	1101
	// 14	1110
	// 25	11001
	// 26	11010
	// 28	11100
	// 49	110001
	// 50	110010
	// 52	110100
	// 56	111000
	//  [7 + 13 + 14 + 25 + 26 + 28 + 49 + 
	//   50 + 52 + 56] = 320
	$task->threeActiveBits(10);
	// Test B
	// num = 20 
	// --------------
	// 7	111
	// 13	1101
	// 14	1110
	// 25	11001
	// 26	11010
	// 28	11100
	// 49	110001
	// 50	110010
	// 52	110100
	// 56	111000
	// 97	1100001
	// 98	1100010
	// 100	1100100
	// 104	1101000
	// 112	1110000
	// 193	11000001
	// 194	11000010
	// 196	11000100
	// 200	11001000
	// 208	11010000
	// [7 + 13 + 14 + 25 + 26 + 28 + 49 + 50 +
	//  52 + 56 + 97 + 98 + 100 + 104 + 112 + 
	//  193 + 194 + 196 + 200 + 208] = 1822
	$task->threeActiveBits(20);
}
main();

Output

 Given n  : 10
 Result   : 320
 Given n  : 20
 Result   : 1822

/*
    Node JS Program
    Sum of n numbers with exactly 3 set bits 
*/
class BinaryBits
{
	threeActiveBits(n)
	{
		var count = n;
		var temp = 1;
		var num = 2;
		var sum = 0;
		while (count > 0)
		{
			num = (num << 1);
			while (temp < (num >> 1) && count > 0)
			{
				sum += (num | (num >> 1) | temp);
				temp = temp << 1;
				count--;
			}
			temp = 1;
		}
		// Display number of element
		console.log(" Given n  : " + n);
		// Display calculate sum
		console.log(" Result   : " + sum);
	}
}

function main()
{
	var task = new BinaryBits();
	// Test A
	// n = 10 
	// --------------
	// 7	111
	// 13	1101
	// 14	1110
	// 25	11001
	// 26	11010
	// 28	11100
	// 49	110001
	// 50	110010
	// 52	110100
	// 56	111000
	//  [7 + 13 + 14 + 25 + 26 + 28 + 49 + 
	//   50 + 52 + 56] = 320
	task.threeActiveBits(10);
	// Test B
	// num = 20 
	// --------------
	// 7	111
	// 13	1101
	// 14	1110
	// 25	11001
	// 26	11010
	// 28	11100
	// 49	110001
	// 50	110010
	// 52	110100
	// 56	111000
	// 97	1100001
	// 98	1100010
	// 100	1100100
	// 104	1101000
	// 112	1110000
	// 193	11000001
	// 194	11000010
	// 196	11000100
	// 200	11001000
	// 208	11010000
	// [7 + 13 + 14 + 25 + 26 + 28 + 49 + 50 +
	//  52 + 56 + 97 + 98 + 100 + 104 + 112 + 
	//  193 + 194 + 196 + 200 + 208] = 1822
	task.threeActiveBits(20);
}
main();

Output

 Given n  : 10
 Result   : 320
 Given n  : 20
 Result   : 1822

#    Python 3 Program
#    Sum of n numbers with exactly 3 set bits 
class BinaryBits :
	def threeActiveBits(self, n) :
		count = n
		temp = 1
		num = 2
		sum = 0
		while (count > 0) :
			num = (num << 1)
			while (temp < (num >> 1) and count > 0) :
				sum += (num | (num >> 1) | temp)
				temp = temp << 1
				count -= 1
			
			temp = 1
		
		#  Display number of element
		print(" Given n  : ", n)
		#  Display calculate sum
		print(" Result   : ", sum)
	

def main() :
	task = BinaryBits()
	#  Test A
	#  n = 10 
	#  --------------
	#  7	111
	#  13	1101
	#  14	1110
	#  25	11001
	#  26	11010
	#  28	11100
	#  49	110001
	#  50	110010
	#  52	110100
	#  56	111000
	#   [7 + 13 + 14 + 25 + 26 + 28 + 49 + 
	#    50 + 52 + 56] = 320
	task.threeActiveBits(10)
	#  Test B
	#  num = 20 
	#  --------------
	#  7	111
	#  13	1101
	#  14	1110
	#  25	11001
	#  26	11010
	#  28	11100
	#  49	110001
	#  50	110010
	#  52	110100
	#  56	111000
	#  97	1100001
	#  98	1100010
	#  100	1100100
	#  104	1101000
	#  112	1110000
	#  193	11000001
	#  194	11000010
	#  196	11000100
	#  200	11001000
	#  208	11010000
	#  [7 + 13 + 14 + 25 + 26 + 28 + 49 + 50 +
	#   52 + 56 + 97 + 98 + 100 + 104 + 112 + 
	#   193 + 194 + 196 + 200 + 208] = 1822
	task.threeActiveBits(20)

if __name__ == "__main__": main()

Output

 Given n  :  10
 Result   :  320
 Given n  :  20
 Result   :  1822

#    Ruby Program
#    Sum of n numbers with exactly 3 set bits 
class BinaryBits 
	def threeActiveBits(n) 
		count = n
		temp = 1
		num = 2
		sum = 0
		while (count > 0) 
			num = (num << 1)
			while (temp < (num >> 1) && count > 0) 
				sum += (num | (num >> 1) | temp)
				temp = temp << 1
				count -= 1
			end

			temp = 1
		end

		#  Display number of element
		print(" Given n  : ", n, "\n")
		#  Display calculate sum
		print(" Result   : ", sum, "\n")
	end

end

def main() 
	task = BinaryBits.new()
	#  Test A
	#  n = 10 
	#  --------------
	#  7	111
	#  13	1101
	#  14	1110
	#  25	11001
	#  26	11010
	#  28	11100
	#  49	110001
	#  50	110010
	#  52	110100
	#  56	111000
	#   [7 + 13 + 14 + 25 + 26 + 28 + 49 + 
	#    50 + 52 + 56] = 320
	task.threeActiveBits(10)
	#  Test B
	#  num = 20 
	#  --------------
	#  7	111
	#  13	1101
	#  14	1110
	#  25	11001
	#  26	11010
	#  28	11100
	#  49	110001
	#  50	110010
	#  52	110100
	#  56	111000
	#  97	1100001
	#  98	1100010
	#  100	1100100
	#  104	1101000
	#  112	1110000
	#  193	11000001
	#  194	11000010
	#  196	11000100
	#  200	11001000
	#  208	11010000
	#  [7 + 13 + 14 + 25 + 26 + 28 + 49 + 50 +
	#   52 + 56 + 97 + 98 + 100 + 104 + 112 + 
	#   193 + 194 + 196 + 200 + 208] = 1822
	task.threeActiveBits(20)
end

main()

Output

 Given n  : 10
 Result   : 320
 Given n  : 20
 Result   : 1822

/*
    Scala Program
    Sum of n numbers with exactly 3 set bits 
*/
class BinaryBits()
{
	def threeActiveBits(n: Int): Unit = {
		var count: Int = n;
		var temp: Int = 1;
		var num: Int = 2;
		var sum: Int = 0;
		while (count > 0)
		{
			num = (num << 1);
			while (temp < (num >> 1) && count > 0)
			{
				sum += (num | (num >> 1) | temp);
				temp = temp << 1;
				count -= 1;
			}
			temp = 1;
		}
		// Display number of element
		println(" Given n  : " + n);
		// Display calculate sum
		println(" Result   : " + sum);
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		var task: BinaryBits = new BinaryBits();
		// Test A
		// n = 10 
		// --------------
		// 7	111
		// 13	1101
		// 14	1110
		// 25	11001
		// 26	11010
		// 28	11100
		// 49	110001
		// 50	110010
		// 52	110100
		// 56	111000
		//  [7 + 13 + 14 + 25 + 26 + 28 + 49 + 
		//   50 + 52 + 56] = 320
		task.threeActiveBits(10);
		// Test B
		// num = 20 
		// --------------
		// 7	111
		// 13	1101
		// 14	1110
		// 25	11001
		// 26	11010
		// 28	11100
		// 49	110001
		// 50	110010
		// 52	110100
		// 56	111000
		// 97	1100001
		// 98	1100010
		// 100	1100100
		// 104	1101000
		// 112	1110000
		// 193	11000001
		// 194	11000010
		// 196	11000100
		// 200	11001000
		// 208	11010000
		// [7 + 13 + 14 + 25 + 26 + 28 + 49 + 50 +
		//  52 + 56 + 97 + 98 + 100 + 104 + 112 + 
		//  193 + 194 + 196 + 200 + 208] = 1822
		task.threeActiveBits(20);
	}
}

Output

 Given n  : 10
 Result   : 320
 Given n  : 20
 Result   : 1822

/*
    Swift 4 Program
    Sum of n numbers with exactly 3 set bits 
*/
class BinaryBits
{
	func threeActiveBits(_ n: Int)
	{
		var count: Int = n;
		var temp: Int = 1;
		var num: Int = 2;
		var sum: Int = 0;
		while (count > 0)
		{
			num = (num << 1);
			while (temp < (num >> 1) && count > 0)
			{
				sum += (num | (num >> 1) | temp);
				temp = temp << 1;
				count -= 1;
			}
			temp = 1;
		}
		// Display number of element
		print(" Given n  : ", n);
		// Display calculate sum
		print(" Result   : ", sum);
	}
}
func main()
{
	let task: BinaryBits = BinaryBits();
	// Test A
	// n = 10 
	// --------------
	// 7	111
	// 13	1101
	// 14	1110
	// 25	11001
	// 26	11010
	// 28	11100
	// 49	110001
	// 50	110010
	// 52	110100
	// 56	111000
	//  [7 + 13 + 14 + 25 + 26 + 28 + 49 + 
	//   50 + 52 + 56] = 320
	task.threeActiveBits(10);
	// Test B
	// num = 20 
	// --------------
	// 7	111
	// 13	1101
	// 14	1110
	// 25	11001
	// 26	11010
	// 28	11100
	// 49	110001
	// 50	110010
	// 52	110100
	// 56	111000
	// 97	1100001
	// 98	1100010
	// 100	1100100
	// 104	1101000
	// 112	1110000
	// 193	11000001
	// 194	11000010
	// 196	11000100
	// 200	11001000
	// 208	11010000
	// [7 + 13 + 14 + 25 + 26 + 28 + 49 + 50 +
	//  52 + 56 + 97 + 98 + 100 + 104 + 112 + 
	//  193 + 194 + 196 + 200 + 208] = 1822
	task.threeActiveBits(20);
}
main();

Output

 Given n  :  10
 Result   :  320
 Given n  :  20
 Result   :  1822

/*
    Kotlin Program
    Sum of n numbers with exactly 3 set bits 
*/
class BinaryBits
{
	fun threeActiveBits(n: Int): Unit
	{
		var count: Int = n;
		var temp: Int = 1;
		var num: Int = 2;
		var sum: Int = 0;
		while (count > 0)
		{
			num = (num shl 1);
			while (temp < (num shr 1) && count > 0)
			{
				sum += (num or(num shr 1) or temp);
				temp = temp shl 1;
				count -= 1;
			}
			temp = 1;
		}
		// Display number of element
		println(" Given n  : " + n);
		// Display calculate sum
		println(" Result   : " + sum);
	}
}
fun main(args: Array < String > ): Unit
{
	val task: BinaryBits = BinaryBits();
	// Test A
	// n = 10 
	// --------------
	// 7	111
	// 13	1101
	// 14	1110
	// 25	11001
	// 26	11010
	// 28	11100
	// 49	110001
	// 50	110010
	// 52	110100
	// 56	111000
	//  [7 + 13 + 14 + 25 + 26 + 28 + 49 + 
	//   50 + 52 + 56] = 320
	task.threeActiveBits(10);
	// Test B
	// num = 20 
	// --------------
	// 7	111
	// 13	1101
	// 14	1110
	// 25	11001
	// 26	11010
	// 28	11100
	// 49	110001
	// 50	110010
	// 52	110100
	// 56	111000
	// 97	1100001
	// 98	1100010
	// 100	1100100
	// 104	1101000
	// 112	1110000
	// 193	11000001
	// 194	11000010
	// 196	11000100
	// 200	11001000
	// 208	11010000
	// [7 + 13 + 14 + 25 + 26 + 28 + 49 + 50 +
	//  52 + 56 + 97 + 98 + 100 + 104 + 112 + 
	//  193 + 194 + 196 + 200 + 208] = 1822
	task.threeActiveBits(20);
}

Output

 Given n  : 10
 Result   : 320
 Given n  : 20
 Result   : 1822

« Previous Next »

Bit Logic

Find position of rightmost set bit

Find the position of leftmost set bit

Count set bits in an integer

Check if all bits of a number is active

Count total bits in a number

Shift active bits to the right side

Find position of all active bits in a number

Perform XNOR of two numbers

Turn off the rightmost set bit

Swap two bits in an integer

Find 1s complement of an Integer

Find most significant set bit of a number

Find the kth least significant bit of a number

Turn on a rightmost unset bit

BCD addition of two decimal numbers

Add two numbers using bitwise operators

Smallest of three integers without comparison operators

Count total set bits in all numbers from 1 to n

Count total unset bits in all numbers from 1 to n

Find position of k-th active bits in a number

Change all bits after most significant bit

Change all odd position bit of a number

Toggle all even bits of a number

Activate all bits of a number

Change first and last bits of a number

Toggle the last n bits

Swap all even and odd bits of a number

Activate all the even position bits of a number

Reverse the bits of a number

Check if two numbers have opposite signs

Hamming distance of two integers

Subtract two numbers using bitwise operators

Check if a number has two adjacent active bits

Check a number is even or odd without using arithmetic operators

Check whether the number has only active first and last bits

Count the number of active and inactive bits of a number

Check if a number has same number of set and unset bits

Add one to given number

Multiplication of two numbers with shift operator

Xor of two numbers without using XOR operator

Find the length of longest consecutive 1s in binary representation

Print first n numbers with exactly two set bits

Generate largest number with given x active and y inactive bits

Sum of bit differences among all pairs

Sum of bit differences for numbers from 0 to N

Check if two numbers are equal using bitwise operators

Find even occurring elements in an array of limited range

Calculate XOR from 1 to n

Swap three variables without using fourth variable

Active all the bits in given range of a number

Swap two numbers using bitwise operator

Check whether all the bits are unset in the given range

Remove nth bit of a number

Append a set bit in given position of a number

Count all unset bit in given range

Turn off a particular bit in a number

Bit difference between two numbers

Count number of bits to be flipped to convert A to B

Find the sum of bit differences among all pairs

Copy set bits in a range

Count number with consecutive 1's in given length

Check that if given number is expressed sum of consecutive or not

Check whether consecutive decreasing active bits exist in a number

Check if a number has bits in alternate pattern

Find nearest power of 2 less than or equal to a number

Highest power of two that divides a given number

Find all powers of 2 less than or equal to a given number

Swap two nibbles in a byte

Swap all adjacent bits in given number

Swap every two bits in bytes

Compare two numbers without using comparison operator

Check whether a number is positive or negative or zero

Highest power of 2 greater than or equal to given number

Check if number is multiple of 3

Efficiently multiply a number by 7

Find next bigger number with same number of set bits

Find the repeating and the missing element using xor

Unset least K significant bits of a given number

Rotate bits of a number

Count pairs with Odd XOR occurrence

Compute modulus division by a power of 2 number

Find two non repeating elements of repeated array elements

Smallest power of 2 greater than or equal to n

Find the majority element using bit logic

Find most significant set bit of a number without inbuilt function

Remove the most significant set bit of a number

Set the leftmost unset bit

Invert k most significant bits of number

Multiply a number by 4 using bitwise operator

Multiply a number by 8 using bitwise operator

Multiply a number by 10 using bitwise operator

Find xor of two numbers without using xor operator

Find missing number in range

Absolute difference between the count of set bits in number and its reverse

Print all numbers less than n which having only boundary bits are set

Print all numbers whose consecutive bits are not similar

Find absolute difference between set and unset bit of a number

Sum of n numbers with exactly 2 active bits set

Sum of n numbers with exactly 3 set bits

Find Nth natural number with exactly two set bits

Check whether given number is power of 2 are efficiently

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.

New Comment

Name