Print all numbers whose consecutive bits are not similar

Here given code implementation process.

// C Program for
// Print all numbers whose consecutive bits are not similar
#include <stdio.h>

void consecutiveDifferent()
{
	int n = 1;
	int bits = 32;
	int count = 1;
	while (count < bits)
	{
		// Display calculated result
		printf("%d\n",n);
		// Shift n value by 1 to left
		n = (n << 1);
		if (count % 2 == 0)
		{
			n += 1;
		}
		count++;
	}
}
int main(int argc, char
	const *argv[])
{
	// 1   01
	// 2   10
	// 5   101
	// 10   1010
	// 21   10101
	// 42   101010
	// 85   1010101
	// 170   10101010
	// 341   101010101
	// 682   1010101010
	// 1365   10101010101
	// 2730   101010101010
	// 5461   1010101010101
	// 10922   10101010101010
	// 21845   101010101010101
	// 43690   1010101010101010
	// 87381   10101010101010101
	// 174762   101010101010101010
	// 349525   1010101010101010101
	// 699050   10101010101010101010
	// 1398101   101010101010101010101
	// 2796202   1010101010101010101010
	// 5592405   10101010101010101010101
	// 11184810   101010101010101010101010
	// 22369621   1010101010101010101010101
	// 44739242   10101010101010101010101010
	// 89478485   101010101010101010101010101
	// 178956970   1010101010101010101010101010
	// 357913941   10101010101010101010101010101
	// 715827882   101010101010101010101010101010
	// 1431655765   1010101010101010101010101010101
	consecutiveDifferent();
	return 0;
}

Output

/*
    Java Program
    Print all numbers whose consecutive bits are not similar
*/
public class BinaryBits
{
	public void consecutiveDifferent()
	{
		int n = 1;
		int bits = 32;
		int count = 1;
		while (count < bits)
		{
			// Display calculated result
			System.out.println(n);
			// Shift n value by 1 to left
			n = (n << 1);
			if (count % 2 == 0)
			{
				n += 1;
			}
			count++;
		}
	}
	public static void main(String[] args)
	{
		BinaryBits task = new BinaryBits();
		// 1   01
		// 2   10
		// 5   101
		// 10   1010
		// 21   10101
		// 42   101010
		// 85   1010101
		// 170   10101010
		// 341   101010101
		// 682   1010101010
		// 1365   10101010101
		// 2730   101010101010
		// 5461   1010101010101
		// 10922   10101010101010
		// 21845   101010101010101
		// 43690   1010101010101010
		// 87381   10101010101010101
		// 174762   101010101010101010
		// 349525   1010101010101010101
		// 699050   10101010101010101010
		// 1398101   101010101010101010101
		// 2796202   1010101010101010101010
		// 5592405   10101010101010101010101
		// 11184810   101010101010101010101010
		// 22369621   1010101010101010101010101
		// 44739242   10101010101010101010101010
		// 89478485   101010101010101010101010101
		// 178956970   1010101010101010101010101010
		// 357913941   10101010101010101010101010101
		// 715827882   101010101010101010101010101010
		// 1431655765   1010101010101010101010101010101
		task.consecutiveDifferent();
	}
}

Output

// Include header file
#include <iostream>

using namespace std;
/*
    C++ Program
    Print all numbers whose consecutive bits are not similar
*/
class BinaryBits
{
	public: void consecutiveDifferent()
	{
		int n = 1;
		int bits = 32;
		int count = 1;
		while (count < bits)
		{
			// Display calculated result
			cout << n << endl;
			// Shift n value by 1 to left
			n = (n << 1);
			if (count % 2 == 0)
			{
				n += 1;
			}
			count++;
		}
	}
};
int main()
{
	BinaryBits *task = new BinaryBits();
	// 1   01
	// 2   10
	// 5   101
	// 10   1010
	// 21   10101
	// 42   101010
	// 85   1010101
	// 170   10101010
	// 341   101010101
	// 682   1010101010
	// 1365   10101010101
	// 2730   101010101010
	// 5461   1010101010101
	// 10922   10101010101010
	// 21845   101010101010101
	// 43690   1010101010101010
	// 87381   10101010101010101
	// 174762   101010101010101010
	// 349525   1010101010101010101
	// 699050   10101010101010101010
	// 1398101   101010101010101010101
	// 2796202   1010101010101010101010
	// 5592405   10101010101010101010101
	// 11184810   101010101010101010101010
	// 22369621   1010101010101010101010101
	// 44739242   10101010101010101010101010
	// 89478485   101010101010101010101010101
	// 178956970   1010101010101010101010101010
	// 357913941   10101010101010101010101010101
	// 715827882   101010101010101010101010101010
	// 1431655765   1010101010101010101010101010101
	task->consecutiveDifferent();
	return 0;
}

Output

// Include namespace system
using System;
/*
    Csharp Program
    Print all numbers whose consecutive bits are not similar
*/
public class BinaryBits
{
	public void consecutiveDifferent()
	{
		int n = 1;
		int bits = 32;
		int count = 1;
		while (count < bits)
		{
			// Display calculated result
			Console.WriteLine(n);
			// Shift n value by 1 to left
			n = (n << 1);
			if (count % 2 == 0)
			{
				n += 1;
			}
			count++;
		}
	}
	public static void Main(String[] args)
	{
		BinaryBits task = new BinaryBits();
		// 1   01
		// 2   10
		// 5   101
		// 10   1010
		// 21   10101
		// 42   101010
		// 85   1010101
		// 170   10101010
		// 341   101010101
		// 682   1010101010
		// 1365   10101010101
		// 2730   101010101010
		// 5461   1010101010101
		// 10922   10101010101010
		// 21845   101010101010101
		// 43690   1010101010101010
		// 87381   10101010101010101
		// 174762   101010101010101010
		// 349525   1010101010101010101
		// 699050   10101010101010101010
		// 1398101   101010101010101010101
		// 2796202   1010101010101010101010
		// 5592405   10101010101010101010101
		// 11184810   101010101010101010101010
		// 22369621   1010101010101010101010101
		// 44739242   10101010101010101010101010
		// 89478485   101010101010101010101010101
		// 178956970   1010101010101010101010101010
		// 357913941   10101010101010101010101010101
		// 715827882   101010101010101010101010101010
		// 1431655765   1010101010101010101010101010101
		task.consecutiveDifferent();
	}
}

Output

package main
import "fmt"
/*
    Go Program
    Print all numbers whose consecutive bits are not similar
*/
type BinaryBits struct {}
func getBinaryBits() * BinaryBits {
	var me *BinaryBits = &BinaryBits {}
	return me
}
func(this BinaryBits) consecutiveDifferent() {
	var n int = 1
	var bits int = 32
	var count int = 1
	for (count < bits) {
		// Display calculated result
		fmt.Println(n)
		// Shift n value by 1 to left
		n = (n << 1)
		if count % 2 == 0 {
			n += 1
		}
		count++
	}
}
func main() {
	var task * BinaryBits = getBinaryBits()
	// 1   01
	// 2   10
	// 5   101
	// 10   1010
	// 21   10101
	// 42   101010
	// 85   1010101
	// 170   10101010
	// 341   101010101
	// 682   1010101010
	// 1365   10101010101
	// 2730   101010101010
	// 5461   1010101010101
	// 10922   10101010101010
	// 21845   101010101010101
	// 43690   1010101010101010
	// 87381   10101010101010101
	// 174762   101010101010101010
	// 349525   1010101010101010101
	// 699050   10101010101010101010
	// 1398101   101010101010101010101
	// 2796202   1010101010101010101010
	// 5592405   10101010101010101010101
	// 11184810   101010101010101010101010
	// 22369621   1010101010101010101010101
	// 44739242   10101010101010101010101010
	// 89478485   101010101010101010101010101
	// 178956970   1010101010101010101010101010
	// 357913941   10101010101010101010101010101
	// 715827882   101010101010101010101010101010
	// 1431655765   1010101010101010101010101010101
	task.consecutiveDifferent()
}

Output

<?php
/*
    Php Program
    Print all numbers whose consecutive bits are not similar
*/
class BinaryBits
{
	public	function consecutiveDifferent()
	{
		$n = 1;
		$bits = 32;
		$count = 1;
		while ($count < $bits)
		{
			// Display calculated result
			echo($n.
				"\n");
			// Shift n value by 1 to left
			$n = ($n << 1);
			if ($count % 2 == 0)
			{
				$n += 1;
			}
			$count++;
		}
	}
}

function main()
{
	$task = new BinaryBits();
	// 1   01
	// 2   10
	// 5   101
	// 10   1010
	// 21   10101
	// 42   101010
	// 85   1010101
	// 170   10101010
	// 341   101010101
	// 682   1010101010
	// 1365   10101010101
	// 2730   101010101010
	// 5461   1010101010101
	// 10922   10101010101010
	// 21845   101010101010101
	// 43690   1010101010101010
	// 87381   10101010101010101
	// 174762   101010101010101010
	// 349525   1010101010101010101
	// 699050   10101010101010101010
	// 1398101   101010101010101010101
	// 2796202   1010101010101010101010
	// 5592405   10101010101010101010101
	// 11184810   101010101010101010101010
	// 22369621   1010101010101010101010101
	// 44739242   10101010101010101010101010
	// 89478485   101010101010101010101010101
	// 178956970   1010101010101010101010101010
	// 357913941   10101010101010101010101010101
	// 715827882   101010101010101010101010101010
	// 1431655765   1010101010101010101010101010101
	$task->consecutiveDifferent();
}
main();

Output

/*
    Node JS Program
    Print all numbers whose consecutive bits are not similar
*/
class BinaryBits
{
	consecutiveDifferent()
	{
		var n = 1;
		var bits = 32;
		var count = 1;
		while (count < bits)
		{
			// Display calculated result
			console.log(n);
			// Shift n value by 1 to left
			n = (n << 1);
			if (count % 2 == 0)
			{
				n += 1;
			}
			count++;
		}
	}
}

function main()
{
	var task = new BinaryBits();
	// 1   01
	// 2   10
	// 5   101
	// 10   1010
	// 21   10101
	// 42   101010
	// 85   1010101
	// 170   10101010
	// 341   101010101
	// 682   1010101010
	// 1365   10101010101
	// 2730   101010101010
	// 5461   1010101010101
	// 10922   10101010101010
	// 21845   101010101010101
	// 43690   1010101010101010
	// 87381   10101010101010101
	// 174762   101010101010101010
	// 349525   1010101010101010101
	// 699050   10101010101010101010
	// 1398101   101010101010101010101
	// 2796202   1010101010101010101010
	// 5592405   10101010101010101010101
	// 11184810   101010101010101010101010
	// 22369621   1010101010101010101010101
	// 44739242   10101010101010101010101010
	// 89478485   101010101010101010101010101
	// 178956970   1010101010101010101010101010
	// 357913941   10101010101010101010101010101
	// 715827882   101010101010101010101010101010
	// 1431655765   1010101010101010101010101010101
	task.consecutiveDifferent();
}
main();

Output

#    Python 3 Program
#    Print all numbers whose consecutive bits are not similar
class BinaryBits :
	def consecutiveDifferent(self) :
		n = 1
		bits = 32
		count = 1
		while (count < bits) :
			#  Display calculated result
			print(n)
			#  Shift n value by 1 to left
			n = (n << 1)
			if (count % 2 == 0) :
				n += 1
			
			count += 1
		
	

def main() :
	task = BinaryBits()
	#  1   01
	#  2   10
	#  5   101
	#  10   1010
	#  21   10101
	#  42   101010
	#  85   1010101
	#  170   10101010
	#  341   101010101
	#  682   1010101010
	#  1365   10101010101
	#  2730   101010101010
	#  5461   1010101010101
	#  10922   10101010101010
	#  21845   101010101010101
	#  43690   1010101010101010
	#  87381   10101010101010101
	#  174762   101010101010101010
	#  349525   1010101010101010101
	#  699050   10101010101010101010
	#  1398101   101010101010101010101
	#  2796202   1010101010101010101010
	#  5592405   10101010101010101010101
	#  11184810   101010101010101010101010
	#  22369621   1010101010101010101010101
	#  44739242   10101010101010101010101010
	#  89478485   101010101010101010101010101
	#  178956970   1010101010101010101010101010
	#  357913941   10101010101010101010101010101
	#  715827882   101010101010101010101010101010
	#  1431655765   1010101010101010101010101010101
	task.consecutiveDifferent()

if __name__ == "__main__": main()

Output

#    Ruby Program
#    Print all numbers whose consecutive bits are not similar
class BinaryBits 
	def consecutiveDifferent() 
		n = 1
		bits = 32
		count = 1
		while (count < bits) 
			#  Display calculated result
			print(n, "\n")
			#  Shift n value by 1 to left
			n = (n << 1)
			if (count % 2 == 0) 
				n += 1
			end

			count += 1
		end

	end

end

def main() 
	task = BinaryBits.new()
	#  1   01
	#  2   10
	#  5   101
	#  10   1010
	#  21   10101
	#  42   101010
	#  85   1010101
	#  170   10101010
	#  341   101010101
	#  682   1010101010
	#  1365   10101010101
	#  2730   101010101010
	#  5461   1010101010101
	#  10922   10101010101010
	#  21845   101010101010101
	#  43690   1010101010101010
	#  87381   10101010101010101
	#  174762   101010101010101010
	#  349525   1010101010101010101
	#  699050   10101010101010101010
	#  1398101   101010101010101010101
	#  2796202   1010101010101010101010
	#  5592405   10101010101010101010101
	#  11184810   101010101010101010101010
	#  22369621   1010101010101010101010101
	#  44739242   10101010101010101010101010
	#  89478485   101010101010101010101010101
	#  178956970   1010101010101010101010101010
	#  357913941   10101010101010101010101010101
	#  715827882   101010101010101010101010101010
	#  1431655765   1010101010101010101010101010101
	task.consecutiveDifferent()
end

main()

Output

/*
    Scala Program
    Print all numbers whose consecutive bits are not similar
*/
class BinaryBits()
{
	def consecutiveDifferent(): Unit = {
		var n: Int = 1;
		var bits: Int = 32;
		var count: Int = 1;
		while (count < bits)
		{
			// Display calculated result
			println(n);
			// Shift n value by 1 to left
			n = (n << 1);
			if (count % 2 == 0)
			{
				n += 1;
			}
			count += 1;
		}
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		var task: BinaryBits = new BinaryBits();
		// 1   01
		// 2   10
		// 5   101
		// 10   1010
		// 21   10101
		// 42   101010
		// 85   1010101
		// 170   10101010
		// 341   101010101
		// 682   1010101010
		// 1365   10101010101
		// 2730   101010101010
		// 5461   1010101010101
		// 10922   10101010101010
		// 21845   101010101010101
		// 43690   1010101010101010
		// 87381   10101010101010101
		// 174762   101010101010101010
		// 349525   1010101010101010101
		// 699050   10101010101010101010
		// 1398101   101010101010101010101
		// 2796202   1010101010101010101010
		// 5592405   10101010101010101010101
		// 11184810   101010101010101010101010
		// 22369621   1010101010101010101010101
		// 44739242   10101010101010101010101010
		// 89478485   101010101010101010101010101
		// 178956970   1010101010101010101010101010
		// 357913941   10101010101010101010101010101
		// 715827882   101010101010101010101010101010
		// 1431655765   1010101010101010101010101010101
		task.consecutiveDifferent();
	}
}

Output

/*
    Swift 4 Program
    Print all numbers whose consecutive bits are not similar
*/
class BinaryBits
{
	func consecutiveDifferent()
	{
		var n: Int = 1;
		let bits: Int = 32;
		var count: Int = 1;
		while (count < bits)
		{
			// Display calculated result
			print(n);
			// Shift n value by 1 to left
			n = (n << 1);
			if (count % 2 == 0)
			{
				n += 1;
			}
			count += 1;
		}
	}
}
func main()
{
	let task: BinaryBits = BinaryBits();
	// 1   01
	// 2   10
	// 5   101
	// 10   1010
	// 21   10101
	// 42   101010
	// 85   1010101
	// 170   10101010
	// 341   101010101
	// 682   1010101010
	// 1365   10101010101
	// 2730   101010101010
	// 5461   1010101010101
	// 10922   10101010101010
	// 21845   101010101010101
	// 43690   1010101010101010
	// 87381   10101010101010101
	// 174762   101010101010101010
	// 349525   1010101010101010101
	// 699050   10101010101010101010
	// 1398101   101010101010101010101
	// 2796202   1010101010101010101010
	// 5592405   10101010101010101010101
	// 11184810   101010101010101010101010
	// 22369621   1010101010101010101010101
	// 44739242   10101010101010101010101010
	// 89478485   101010101010101010101010101
	// 178956970   1010101010101010101010101010
	// 357913941   10101010101010101010101010101
	// 715827882   101010101010101010101010101010
	// 1431655765   1010101010101010101010101010101
	task.consecutiveDifferent();
}
main();

Output

/*
    Kotlin Program
    Print all numbers whose consecutive bits are not similar
*/
class BinaryBits
{
	fun consecutiveDifferent(): Unit
	{
		var n: Int = 1;
		val bits: Int = 32;
		var count: Int = 1;
		while (count < bits)
		{
			// Display calculated result
			println(n);
			// Shift n value by 1 to left
			n = (n shl 1);
			if (count % 2 == 0)
			{
				n += 1;
			}
			count += 1;
		}
	}
}
fun main(args: Array < String > ): Unit
{
	val task: BinaryBits = BinaryBits();
	// 1   01
	// 2   10
	// 5   101
	// 10   1010
	// 21   10101
	// 42   101010
	// 85   1010101
	// 170   10101010
	// 341   101010101
	// 682   1010101010
	// 1365   10101010101
	// 2730   101010101010
	// 5461   1010101010101
	// 10922   10101010101010
	// 21845   101010101010101
	// 43690   1010101010101010
	// 87381   10101010101010101
	// 174762   101010101010101010
	// 349525   1010101010101010101
	// 699050   10101010101010101010
	// 1398101   101010101010101010101
	// 2796202   1010101010101010101010
	// 5592405   10101010101010101010101
	// 11184810   101010101010101010101010
	// 22369621   1010101010101010101010101
	// 44739242   10101010101010101010101010
	// 89478485   101010101010101010101010101
	// 178956970   1010101010101010101010101010
	// 357913941   10101010101010101010101010101
	// 715827882   101010101010101010101010101010
	// 1431655765   1010101010101010101010101010101
	task.consecutiveDifferent();
}

Output

« 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