Skip to main content

Check whether consecutive decreasing active bits exist in a number

Given a positive integer, check whether the binary representation bits restrict the decreasing order of continuously active bits present in the right-to-left direction or not. For example, valid decreasing contiguous sequence. 


Example 1 :
------------
num = 398 (000110001110) Binary bits
First pair of consecutive set bits is
(111) length is 3
Second pair of consecutive set bits is
(11)  length is 2
Valid decreasing order (3 > 2 ) (Right to left)

Output : Yes

Example 2 :
------------
num = 623 (1001101111)
First pair of consecutive set bits is
(1111) length is 4
Second pair of consecutive set bits is
(11)  length is 2
Third pair of consecutive set bits is
(1)  length is 1

Valid decreasing order (4 > 2 > 1)

Output : Yes


Example 3 :
-----------
num = 46 (101110)
First pair of consecutive set bits is
(111) length is 3
Second pair of consecutive set bits is
(1)  length is 1
Valid decreasing order ( 2 > 1)
Output : Yes

Example 4 :
------------
num = 14 (1110)
First pair of consecutive set bits is
(111) length is 3

Any one pair of active bits are valid


Output : Yes

Some of case which is not valid to this problem their examples such as follows.

Example 1 :
27  (11011)
First pair of consecutive set bits is
(11) length is 2
Second pair of consecutive set bits is
(11)  length is 2
Valid decreasing order (2 > 2) Not true
Output : No

Example 2:
58 (111010)
First pair of consecutive set bits is
(1) length is 1
Second pair of consecutive set bits is
(111)  length is 3
Valid decreasing order (1 > 3) Not true

Output : No

Here given code implementation process.

// C program 
// Check whether consecutive decreasing active bits exist in a number
#include <stdio.h>

// Determine that given number have binary active bits in decreasing order or not
void decreasingActiveBit(int num)
{
	if (num < 0)
	{
		return;
	}
	// Define some auxiliary variables
	int count = 0;
	int result = 0;
	int temp = num;
	// Execute loop until temp is gratore than zero and
	// Consecutive active bit length is decreasing order 
	// in form of right to left
	while (temp > 0 && result != -1)
	{
		if ((temp & 1) == 1)
		{
			// Count consecutive active bit length
			count++;
		}
		else if (count > 0)
		{
			if (result == 0)
			{
				// Get first sequence of active bits
				result = count;
			}
			else if (result > count)
			{
				// Get next small active bits pair length
				result = count;
			}
			else
			{
				// When next active pair length is greater
				result = -1;
			}
			count = 0;
		}
		// Shift by one bit to left
		temp = temp >> 1;
	}
	if (result == 0 && count > 0)
	{
		// Whe only first pair exist
		result = count;
	}
	else if (count >= result)
	{
		// When left side consecutive set bits length are not smaller  
		result = -1;
	}
	// Display given number
	printf("\n Number : %d", num);
	if (result == -1)
	{
		printf("\n No");
	}
	else
	{
		printf("\n Yes");
	}
}
int main(int argc, char
	const *argv[])
{
	int num = 567;
	// 567 (1000110111)
	decreasingActiveBit(num);
	num = 439;
	// 439 (110110111)
	decreasingActiveBit(num);
	num = 7;
	// 7 (111)
	decreasingActiveBit(num);
	num = 92;
	// 92 (1011100)
	decreasingActiveBit(num);
	num = 29;
	// 29 (11101)
	decreasingActiveBit(num);
	return 0;
}

Output

 Number : 567
 Yes
 Number : 439
 No
 Number : 7
 Yes
 Number : 92
 Yes
 Number : 29
 No
/*
  Java program
  Check whether consecutive decreasing active bits exist in a number
*/
public class Sequence
{
	// Determine that given number have binary active bits in decreasing order or not
	public void decreasingActiveBit(int num)
	{
		if (num < 0)
		{
			return;
		}
		// Define some auxiliary variables
		int count = 0;
		int result = 0;
		int temp = num;
		// Execute loop until temp is gratore than zero and
		// Consecutive active bit length is decreasing order 
		// in form of right to left
		while (temp > 0 && result != -1)
		{
			if ((temp & 1) == 1)
			{
				// Count consecutive active bit length
				count++;
			}
			else if (count > 0)
			{
				if (result == 0)
				{
					// Get first sequence of active bits
					result = count;
				}
				else if (result > count)
				{
					// Get next small active bits pair length
					result = count;
				}
				else
				{
					// When next active pair length is greater
					result = -1;
				}
				count = 0;
			}
			// Shift by one bit to left
			temp = temp >> 1;
		}
		if (result == 0 && count > 0)
		{
			// Whe only first pair exist
			result = count;
		}
		else if (count >= result)
		{
			// When left side consecutive set bits length are not smaller  
			result = -1;
		}
		// Display given number
		System.out.print("\n Number : " + num + "");
		if (result == -1)
		{
			System.out.print("\n No");
		}
		else
		{
			System.out.print("\n Yes");
		}
	}
	public static void main(String[] args)
	{
		Sequence task = new Sequence();
		int num = 567;
		// 567 (1000110111)
		task.decreasingActiveBit(num);
		num = 439;
		// 439 (110110111)
		task.decreasingActiveBit(num);
		num = 7;
		// 7 (111)
		task.decreasingActiveBit(num);
		num = 92;
		// 92 (1011100)
		task.decreasingActiveBit(num);
		num = 29;
		// 29 (11101)
		task.decreasingActiveBit(num);
	}
}

Output

 Number : 567
 Yes
 Number : 439
 No
 Number : 7
 Yes
 Number : 92
 Yes
 Number : 29
 No
// Include header file
#include <iostream>
using namespace std;

/*
  C++ program
  Check whether consecutive decreasing active bits exist in a number
*/

class Sequence
{
	public:
		// Determine that given number have binary active bits in decreasing order or not
		void decreasingActiveBit(int num)
		{
			if (num < 0)
			{
				return;
			}
			// Define some auxiliary variables
			int count = 0;
			int result = 0;
			int temp = num;
			// Execute loop until temp is gratore than zero and
			// Consecutive active bit length is decreasing order
			// in form of right to left
			while (temp > 0 && result != -1)
			{
				if ((temp &1) == 1)
				{
					// Count consecutive active bit length
					count++;
				}
				else if (count > 0)
				{
					if (result == 0)
					{
						// Get first sequence of active bits
						result = count;
					}
					else if (result > count)
					{
						// Get next small active bits pair length
						result = count;
					}
					else
					{
						// When next active pair length is greater
						result = -1;
					}
					count = 0;
				}
				// Shift by one bit to left
				temp = temp >> 1;
			}
			if (result == 0 && count > 0)
			{
				// Whe only first pair exist
				result = count;
			}
			else if (count >= result)
			{
				// When left side consecutive set bits length are not smaller
				result = -1;
			}
			// Display given number
			cout << "\n Number : " << num << "";
			if (result == -1)
			{
				cout << "\n No";
			}
			else
			{
				cout << "\n Yes";
			}
		}
};
int main()
{
	Sequence task = Sequence();
	int num = 567;
	// 567 (1000110111)
	task.decreasingActiveBit(num);
	num = 439;
	// 439 (110110111)
	task.decreasingActiveBit(num);
	num = 7;
	// 7 (111)
	task.decreasingActiveBit(num);
	num = 92;
	// 92 (1011100)
	task.decreasingActiveBit(num);
	num = 29;
	// 29 (11101)
	task.decreasingActiveBit(num);
	return 0;
}

Output

 Number : 567
 Yes
 Number : 439
 No
 Number : 7
 Yes
 Number : 92
 Yes
 Number : 29
 No
// Include namespace system
using System;
/*
  C# program
  Check whether consecutive decreasing active bits exist in a number
*/
public class Sequence
{
	// Determine that given number have binary active bits in decreasing order or not
	public void decreasingActiveBit(int num)
	{
		if (num < 0)
		{
			return;
		}
		// Define some auxiliary variables
		int count = 0;
		int result = 0;
		int temp = num;
		// Execute loop until temp is gratore than zero and
		// Consecutive active bit length is decreasing order
		// in form of right to left
		while (temp > 0 && result != -1)
		{
			if ((temp & 1) == 1)
			{
				// Count consecutive active bit length
				count++;
			}
			else if (count > 0)
			{
				if (result == 0)
				{
					// Get first sequence of active bits
					result = count;
				}
				else if (result > count)
				{
					// Get next small active bits pair length
					result = count;
				}
				else
				{
					// When next active pair length is greater
					result = -1;
				}
				count = 0;
			}
			// Shift by one bit to left
			temp = temp >> 1;
		}
		if (result == 0 && count > 0)
		{
			// Whe only first pair exist
			result = count;
		}
		else if (count >= result)
		{
			// When left side consecutive set bits length are not smaller
			result = -1;
		}
		// Display given number
		Console.Write("\n Number : " + num + "");
		if (result == -1)
		{
			Console.Write("\n No");
		}
		else
		{
			Console.Write("\n Yes");
		}
	}
	public static void Main(String[] args)
	{
		Sequence task = new Sequence();
		int num = 567;
		// 567 (1000110111)
		task.decreasingActiveBit(num);
		num = 439;
		// 439 (110110111)
		task.decreasingActiveBit(num);
		num = 7;
		// 7 (111)
		task.decreasingActiveBit(num);
		num = 92;
		// 92 (1011100)
		task.decreasingActiveBit(num);
		num = 29;
		// 29 (11101)
		task.decreasingActiveBit(num);
	}
}

Output

 Number : 567
 Yes
 Number : 439
 No
 Number : 7
 Yes
 Number : 92
 Yes
 Number : 29
 No
<?php
/*
  Php program
  Check whether consecutive decreasing active bits exist in a number
*/
class Sequence
{
	// Determine that given number have binary active bits in decreasing order or not
	public	function decreasingActiveBit($num)
	{
		if ($num < 0)
		{
			return;
		}
		// Define some auxiliary variables
		$count = 0;
		$result = 0;
		$temp = $num;
		// Execute loop until temp is gratore than zero and
		// Consecutive active bit length is decreasing order
		// in form of right to left
		while ($temp > 0 && $result != -1)
		{
			if (($temp & 1) == 1)
			{
				// Count consecutive active bit length
				$count++;
			}
			else if ($count > 0)
			{
				if ($result == 0)
				{
					// Get first sequence of active bits
					$result = $count;
				}
				else if ($result > $count)
				{
					// Get next small active bits pair length
					$result = $count;
				}
				else
				{
					// When next active pair length is greater
					$result = -1;
				}
				$count = 0;
			}
			// Shift by one bit to left
			$temp = $temp >> 1;
		}
		if ($result == 0 && $count > 0)
		{
			// Whe only first pair exist
			$result = $count;
		}
		else if ($count >= $result)
		{
			// When left side consecutive set bits length are not smaller
			$result = -1;
		}
		// Display given number
		echo "\n Number : ". $num ."";
		if ($result == -1)
		{
			echo "\n No";
		}
		else
		{
			echo "\n Yes";
		}
	}
}

function main()
{
	$task = new Sequence();
	$num = 567;
	// 567 (1000110111)
	$task->decreasingActiveBit($num);
	$num = 439;
	// 439 (110110111)
	$task->decreasingActiveBit($num);
	$num = 7;
	// 7 (111)
	$task->decreasingActiveBit($num);
	$num = 92;
	// 92 (1011100)
	$task->decreasingActiveBit($num);
	$num = 29;
	// 29 (11101)
	$task->decreasingActiveBit($num);
}
main();

Output

 Number : 567
 Yes
 Number : 439
 No
 Number : 7
 Yes
 Number : 92
 Yes
 Number : 29
 No
/*
  Node Js program
  Check whether consecutive decreasing active bits exist in a number
*/
class Sequence
{
	// Determine that given number have binary active bits in decreasing order or not
	decreasingActiveBit(num)
	{
		if (num < 0)
		{
			return;
		}
		// Define some auxiliary variables
		var count = 0;
		var result = 0;
		var temp = num;
		// Execute loop until temp is gratore than zero and
		// Consecutive active bit length is decreasing order
		// in form of right to left
		while (temp > 0 && result != -1)
		{
			if ((temp & 1) == 1)
			{
				// Count consecutive active bit length
				count++;
			}
			else if (count > 0)
			{
				if (result == 0)
				{
					// Get first sequence of active bits
					result = count;
				}
				else if (result > count)
				{
					// Get next small active bits pair length
					result = count;
				}
				else
				{
					// When next active pair length is greater
					result = -1;
				}
				count = 0;
			}
			// Shift by one bit to left
			temp = temp >> 1;
		}
		if (result == 0 && count > 0)
		{
			// Whe only first pair exist
			result = count;
		}
		else if (count >= result)
		{
			// When left side consecutive set bits length are not smaller
			result = -1;
		}
		// Display given number
		process.stdout.write("\n Number : " + num + "");
		if (result == -1)
		{
			process.stdout.write("\n No");
		}
		else
		{
			process.stdout.write("\n Yes");
		}
	}
}

function main()
{
	var task = new Sequence();
	var num = 567;
	// 567 (1000110111)
	task.decreasingActiveBit(num);
	num = 439;
	// 439 (110110111)
	task.decreasingActiveBit(num);
	num = 7;
	// 7 (111)
	task.decreasingActiveBit(num);
	num = 92;
	// 92 (1011100)
	task.decreasingActiveBit(num);
	num = 29;
	// 29 (11101)
	task.decreasingActiveBit(num);
}
main();

Output

 Number : 567
 Yes
 Number : 439
 No
 Number : 7
 Yes
 Number : 92
 Yes
 Number : 29
 No
#   Python 3 program
#   Check whether consecutive decreasing active bits exist in a number

class Sequence :
	#  Determine that given number have binary active bits in decreasing order or not
	def decreasingActiveBit(self, num) :
		if (num < 0) :
			return
		
		#  Define some auxiliary variables
		count = 0
		result = 0
		temp = num
		#  Execute loop until temp is gratore than zero and
		#  Consecutive active bit length is decreasing order 
		#  in form of right to left
		while (temp > 0 and result != -1) :
			if ((temp & 1) == 1) :
				#  Count consecutive active bit length
				count += 1
			
			elif(count > 0) :
				if (result == 0) :
					#  Get first sequence of active bits
					result = count
				
				elif(result > count) :
					#  Get next small active bits pair length
					result = count
				else :
					#  When next active pair length is greater
					result = -1
				
				count = 0
			
			#  Shift by one bit to left
			temp = temp >> 1
		
		if (result == 0 and count > 0) :
			#  Whe only first pair exist
			result = count
		
		elif(count >= result) :
			#  When left side consecutive set bits length are not smaller  
			result = -1
		
		#  Display given number
		print("\n Number : ", num ,"", end = "")
		if (result == -1) :
			print("\n No", end = "")
		else :
			print("\n Yes", end = "")
		
	

def main() :
	task = Sequence()
	num = 567
	#  567 (1000110111)
	task.decreasingActiveBit(num)
	num = 439
	#  439 (110110111)
	task.decreasingActiveBit(num)
	num = 7
	#  7 (111)
	task.decreasingActiveBit(num)
	num = 92
	#  92 (1011100)
	task.decreasingActiveBit(num)
	num = 29
	#  29 (11101)
	task.decreasingActiveBit(num)

if __name__ == "__main__": main()

Output

 Number :  567
 Yes
 Number :  439
 No
 Number :  7
 Yes
 Number :  92
 Yes
 Number :  29
 No
#   Ruby program
#   Check whether consecutive decreasing active bits exist in a number

class Sequence 
	#  Determine that given number have binary active bits in decreasing order or not
	def decreasingActiveBit(num) 
		if (num < 0) 
			return
		end

		#  Define some auxiliary variables
		count = 0
		result = 0
		temp = num
		#  Execute loop until temp is gratore than zero and
		#  Consecutive active bit length is decreasing order 
		#  in form of right to left
		while (temp > 0 && result != -1) 
			if ((temp & 1) == 1) 
				#  Count consecutive active bit length
				count += 1
			elsif(count > 0) 
				if (result == 0) 
					#  Get first sequence of active bits
					result = count
				elsif(result > count) 
					#  Get next small active bits pair length
					result = count
				else 
					#  When next active pair length is greater
					result = -1
				end

				count = 0
			end

			#  Shift by one bit to left
			temp = temp >> 1
		end

		if (result == 0 && count > 0) 
			#  Whe only first pair exist
			result = count
		elsif(count >= result) 
			#  When left side consecutive set bits length are not smaller  
			result = -1
		end

		#  Display given number
		print("\n Number : ", num ,"")
		if (result == -1) 
			print("\n No")
		else 
			print("\n Yes")
		end

	end

end

def main() 
	task = Sequence.new()
	num = 567
	#  567 (1000110111)
	task.decreasingActiveBit(num)
	num = 439
	#  439 (110110111)
	task.decreasingActiveBit(num)
	num = 7
	#  7 (111)
	task.decreasingActiveBit(num)
	num = 92
	#  92 (1011100)
	task.decreasingActiveBit(num)
	num = 29
	#  29 (11101)
	task.decreasingActiveBit(num)
end

main()

Output

 Number : 567
 Yes
 Number : 439
 No
 Number : 7
 Yes
 Number : 92
 Yes
 Number : 29
 No
/*
  Scala program
  Check whether consecutive decreasing active bits exist in a number
*/
class Sequence
{
	// Determine that given number have binary active bits in decreasing order or not
	def decreasingActiveBit(num: Int): Unit = {
		if (num < 0)
		{
			return;
		}
		// Define some auxiliary variables
		var count: Int = 0;
		var result: Int = 0;
		var temp: Int = num;
		// Execute loop until temp is gratore than zero and
		// Consecutive active bit length is decreasing order
		// in form of right to left
		while (temp > 0 && result != -1)
		{
			if ((temp & 1) == 1)
			{
				// Count consecutive active bit length
				count += 1;
			}
			else if (count > 0)
			{
				if (result == 0)
				{
					// Get first sequence of active bits
					result = count;
				}
				else if (result > count)
				{
					// Get next small active bits pair length
					result = count;
				}
				else
				{
					// When next active pair length is greater
					result = -1;
				}
				count = 0;
			}
			// Shift by one bit to left
			temp = temp >> 1;
		}
		if (result == 0 && count > 0)
		{
			// Whe only first pair exist
			result = count;
		}
		else if (count >= result)
		{
			// When left side consecutive set bits length are not smaller
			result = -1;
		}
		// Display given number
		print("\n Number : " + num + "");
		if (result == -1)
		{
			print("\n No");
		}
		else
		{
			print("\n Yes");
		}
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		var task: Sequence = new Sequence();
		var num: Int = 567;
		// 567 (1000110111)
		task.decreasingActiveBit(num);
		num = 439;
		// 439 (110110111)
		task.decreasingActiveBit(num);
		num = 7;
		// 7 (111)
		task.decreasingActiveBit(num);
		num = 92;
		// 92 (1011100)
		task.decreasingActiveBit(num);
		num = 29;
		// 29 (11101)
		task.decreasingActiveBit(num);
	}
}

Output

 Number : 567
 Yes
 Number : 439
 No
 Number : 7
 Yes
 Number : 92
 Yes
 Number : 29
 No
/*
  Swift 4 program
  Check whether consecutive decreasing active bits exist in a number
*/
class Sequence
{
	// Determine that given number have binary active bits in decreasing order or not
	func decreasingActiveBit(_ num: Int)
	{
		if (num < 0)
		{
			return;
		}
		// Define some auxiliary variables
		var count: Int = 0;
		var result: Int = 0;
		var temp: Int = num;
		// Execute loop until temp is gratore than zero and
		// Consecutive active bit length is decreasing order
		// in form of right to left
		while (temp > 0 && result  != -1)
		{
			if ((temp & 1) == 1)
			{
				// Count consecutive active bit length
				count += 1;
			}
			else if (count > 0)
			{
				if (result == 0)
				{
					// Get first sequence of active bits
					result = count;
				}
				else if (result > count)
				{
					// Get next small active bits pair length
					result = count;
				}
				else
				{
					// When next active pair length is greater
					result = -1;
				}
				count = 0;
			}
			// Shift by one bit to left
			temp = temp >> 1;
		}
		if (result == 0 && count > 0)
		{
			// Whe only first pair exist
			result = count;
		}
		else if (count >= result)
		{
			// When left side consecutive set bits length are not smaller
			result = -1;
		}
		// Display given number
		print("\n Number : ", num ,"", terminator: "");
		if (result == -1)
		{
			print("\n No", terminator: "");
		}
		else
		{
			print("\n Yes", terminator: "");
		}
	}
}
func main()
{
	let task: Sequence = Sequence();
	var num: Int = 567;
	// 567 (1000110111)
	task.decreasingActiveBit(num);
	num = 439;
	// 439 (110110111)
	task.decreasingActiveBit(num);
	num = 7;
	// 7 (111)
	task.decreasingActiveBit(num);
	num = 92;
	// 92 (1011100)
	task.decreasingActiveBit(num);
	num = 29;
	// 29 (11101)
	task.decreasingActiveBit(num);
}
main();

Output

 Number :  567
 Yes
 Number :  439
 No
 Number :  7
 Yes
 Number :  92
 Yes
 Number :  29
 No
/*
  Kotlin program
  Check whether consecutive decreasing active bits exist in a number
*/
class Sequence
{
	// Determine that given number have binary active bits in decreasing order or not
	fun decreasingActiveBit(num: Int): Unit
	{
		if (num < 0)
		{
			return;
		}
		// Define some auxiliary variables
		var count: Int = 0;
		var result: Int = 0;
		var temp: Int = num;
		// Execute loop until temp is gratore than zero and
		// Consecutive active bit length is decreasing order
		// in form of right to left
		while (temp > 0 && result != -1)
		{
			if ((temp and 1) == 1)
			{
				// Count consecutive active bit length
				count += 1;
			}
			else if (count > 0)
			{
				if (result == 0)
				{
					// Get first sequence of active bits
					result = count;
				}
				else if (result > count)
				{
					// Get next small active bits pair length
					result = count;
				}
				else
				{
					// When next active pair length is greater
					result = -1;
				}
				count = 0;
			}
			// Shift by one bit to left
			temp = temp shr 1;
		}
		if (result == 0 && count > 0)
		{
			// Whe only first pair exist
			result = count;
		}
		else if (count >= result)
		{
			// When left side consecutive set bits length are not smaller
			result = -1;
		}
		// Display given number
		print("\n Number : " + num + "");
		if (result == -1)
		{
			print("\n No");
		}
		else
		{
			print("\n Yes");
		}
	}
}
fun main(args: Array <String> ): Unit
{
	var task: Sequence = Sequence();
	var num: Int = 567;
	// 567 (1000110111)
	task.decreasingActiveBit(num);
	num = 439;
	// 439 (110110111)
	task.decreasingActiveBit(num);
	num = 7;
	// 7 (111)
	task.decreasingActiveBit(num);
	num = 92;
	// 92 (1011100)
	task.decreasingActiveBit(num);
	num = 29;
	// 29 (11101)
	task.decreasingActiveBit(num);
}

Output

 Number : 567
 Yes
 Number : 439
 No
 Number : 7
 Yes
 Number : 92
 Yes
 Number : 29
 No
Last updated on by Kalkicode




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