Compruebe si la representación binaria de un número tiene el mismo número de 0 y 1 en bloques

Dado un número entero N, la tarea es verificar si su número binario equivalente tiene la misma frecuencia de bloques consecutivos de 0 y 1. Tenga en cuenta que 0 y un número con todos 1 no se considera que tengan un número de bloques de 0 y 1.

Ejemplos:  

Entrada: N = 5 
Salida: Sí  El
número binario equivalente de 5 es 101. 
El primer bloque es de 1 con longitud 1, el segundo bloque es de 0 con longitud 1 
y el tercer bloque es de 1 y también de longitud 1. Entonces, todos los bloques de 0 y 1 tienen una frecuencia igual que es 1.

Entrada: N = 51 
Salida: Sí  El
número binario equivalente de 51 es 110011.

Entrada: 8 
Salida: No

Entrada: 7 
Salida: No 

Enfoque simple: primero convierta el número entero a su número binario equivalente. Recorra la string binaria de izquierda a derecha, para cada bloque de 1 o 0, encuentre su longitud y agréguela en un conjunto. Si la longitud del conjunto es 1, escriba «Sí», de lo contrario, escriba «No». 

// C++ implementation of the above 
// approach 
#include <bits/stdc++.h>
using namespace std;
 
// Function to check
void hasEqualBlockFrequency(int N)
{
 
  // Converting integer to its equivalent 
  // binary number
  string S = bitset<3> (N).to_string();
  set<int> p;
  int c = 1;
 
  for(int i = 0; i < S.length(); i++)
  {
 
    // If adjacent character are same 
    // then increase counter
    if (S[i] == S[i + 1])
      c += 1;
 
    else
    {
      p.insert(c);
      c = 1;
    }
    p.insert(c);
  }
 
  if (p.size() == 1)
    cout << "Yes" << endl;
  else
    cout << "No" << endl;
}
 
// Driver code
int main()
{
  int N = 5;
  hasEqualBlockFrequency(N);
  return 0;
}
 
// This code is contributed by divyesh072019

// Java implementation of the above 
// approach 
import java.util.*;
  
class GFG{
    
// Function to check
static void hasEqualBlockFrequency(int N)
{
     
    // Converting integer to its equivalent 
    // binary number
    String S = Integer.toString(N,2);
    HashSet<Integer> p = new HashSet<Integer>();
    int c = 1;
      
    for(int i = 0; i < S.length() - 1; i++)
    {
         
        // If adjacent character are same 
        // then increase counter
        if (S.charAt(i) == S.charAt(i + 1))
            c += 1;
          
        else
        {
            p.add(c);
            c = 1;
        }
        p.add(c);
    }
      
    if (p.size() == 1)
        System.out.println("Yes");
    else
        System.out.println("No");
}
  
// Driver Code
public static void main(String []args)
{
    int N = 5;
      
    hasEqualBlockFrequency(N);
}
}
 
// This code is contributed by rutvik_56

# Python3 implementation of the above
# approach
   
# Function to check
def hasEqualBlockFrequency(N):
   
    # Converting integer to its equivalent
    # binary number
    S = bin(N).replace("0b", "")
    p = set()
    c = 1
 
    for i in range(len(S)-1):
 
        # If adjacent character are same
        # then increase counter
        if (S[i] == S[i + 1]):
            c += 1
 
        else:
            p.add(c)
            c = 1
 
        p.add(c)
 
    if (len(p) == 1):
        print("Yes")
    else:
        print("No")
 
# Driver code
N = 5
hasEqualBlockFrequency(N)

// C# implementation of the above 
// approach 
using System;
using System.Collections.Generic;
 
class GFG{
   
// Function to check
static void hasEqualBlockFrequency(int N)
{
     
    // Converting integer to its equivalent 
    // binary number
    string S = Convert.ToString(N, 2);
    HashSet<int> p = new HashSet<int>();
    int c = 1;
     
    for(int i = 0; i < S.Length - 1; i++)
    {
         
        // If adjacent character are same 
        // then increase counter
        if (S[i] == S[i + 1])
            c += 1;
         
        else
        {
            p.Add(c);
            c = 1;
        }
        p.Add(c);
    }
     
    if (p.Count == 1)
        Console.WriteLine("Yes");
    else
        Console.WriteLine("No");
}
 
// Driver Code
static void Main()
{
    int N = 5;
     
    hasEqualBlockFrequency(N);
}
}
 
// This code is contributed by divyeshrabadiya07

<script>
 
  // JavaScript implementation of the above approach
   
  // Function to check
  function hasEqualBlockFrequency(N)
  {
        
      // Converting integer to its equivalent
      // binary number
      let S = N.toString(2);
      let p = new Set();
      let c = 1;
        
      for(let i = 0; i < S.length - 1; i++)
      {
            
          // If adjacent character are same
          // then increase counter
          if (S[i] == S[i + 1])
              c += 1;
            
          else
          {
              p.add(c);
              c = 1;
          }
          p.add(c);
      }
        
      if (p.size == 1)
          document.write("Yes");
      else
          document.write("No");
  }
   
  let N = 5;
      
  hasEqualBlockFrequency(N);
     
</script>

Yes

Solución optimizada: Recorremos desde el último bit. Primero contamos el número de bits iguales en el último bloque. Luego recorremos todos los bits, para cada bloque, contamos el número de bits iguales y si este recuento no es el mismo que el primero, devolvemos falso. Si todos los bloques tienen el mismo conteo, devolvemos verdadero.

// C++ program to check if a number has
// same counts of 0s and 1s in every
// block.
 
#include <iostream>
using namespace std;
 
// function to convert decimal to binary
bool isEqualBlock(int n)
{
    // Count same bits in last block
    int first_bit = n % 2;
    int first_count = 1;
    n = n / 2;
    while (n % 2 == first_bit && n > 0) {
        n = n / 2;
        first_count++;
    }
 
    // If n is 0 or it has all 1s,
    // then it is not considered to
    // have equal number of 0s and
    // 1s in blocks.
    if (n == 0)
        return false;
 
    // Count same bits in all remaining blocks.
    while (n > 0) {
 
        int first_bit = n % 2;
        int curr_count = 1;
        n = n / 2;
        while (n % 2 == first_bit) {
            n = n / 2;
            curr_count++;
        }
 
        if (curr_count != first_count)
            return false;
    }
 
    return true;
}
 
// Driver program to test above function
int main()
{
    int n = 51;
    if (isEqualBlock(n))
        cout << "Yes";
    else
        cout << "No";
    return 0;
}

// Java program to check if a number has
// same counts of 0s and 1s in every
// block.
import java.io.*;
 
class GFG
{
 
// function to convert decimal to binary
static boolean isEqualBlock(int n)
{
    // Count same bits in last block
    int first_bit = n % 2;
    int first_count = 1;
    n = n / 2;
    while (n % 2 == first_bit && n > 0)
    {
        n = n / 2;
        first_count++;
    }
 
    // If n is 0 or it has all 1s,
    // then it is not considered to
    // have equal number of 0s and
    // 1s in blocks.
    if (n == 0)
        return false;
 
    // Count same bits in all remaining blocks.
    while (n > 0)
    {
 
        first_bit = n % 2;
        int curr_count = 1;
        n = n / 2;
        while (n % 2 == first_bit)
        {
            n = n / 2;
            curr_count++;
        }
 
        if (curr_count != first_count)
            return false;
    }
    return true;
}
 
// Driver code
public static void main (String[] args)
{
    int n = 51;
    if (isEqualBlock(n))
        System.out.println( "Yes");
    else
        System.out.println("No");
}
}
 
// This code is contributed by inder_mca

# Python3 program to check if a number has
# same counts of 0s and 1s in every block.
 
# Function to convert decimal to binary
def isEqualBlock(n):
 
    # Count same bits in last block
    first_bit = n % 2
    first_count = 1
    n = n // 2
    while n % 2 == first_bit and n > 0:
        n = n // 2
        first_count += 1
 
    # If n is 0 or it has all 1s,
    # then it is not considered to
    # have equal number of 0s and
    # 1s in blocks.
    if n == 0:
        return False
 
    # Count same bits in all remaining blocks.
    while n > 0:
 
        first_bit = n % 2
        curr_count = 1
        n = n // 2
        while n % 2 == first_bit:
            n = n // 2
            curr_count += 1
         
        if curr_count != first_count:
            return False
     
    return True
 
# Driver Code
if __name__ == "__main__":
 
    n = 51
    if isEqualBlock(n):
        print("Yes")
    else:
        print("No")
     
# This code is contributed by
# Rituraj Jain

// C# program to check if a number has
// same counts of 0s and 1s in every
// block.
 
using System;
 
class GFG
{
 
    // function to convert decimal to binary
    static bool isEqualBlock(int n)
    {
        // Count same bits in last block
        int first_bit = n % 2;
        int first_count = 1;
        n = n / 2;
        while (n % 2 == first_bit && n > 0)
        {
            n = n / 2;
            first_count++;
        }
     
        // If n is 0 or it has all 1s,
        // then it is not considered to
        // have equal number of 0s and
        // 1s in blocks.
        if (n == 0)
            return false;
     
        // Count same bits in all remaining blocks.
        while (n > 0)
        {
     
            first_bit = n % 2;
            int curr_count = 1;
            n = n / 2;
             
            while (n % 2 == first_bit)
            {
                n = n / 2;
                curr_count++;
            }
             
            if (curr_count != first_count)
                return false;
        }
        return true;
    }
     
    // Driver code
    public static void Main ()
    {
        int n = 51;
         
        if (isEqualBlock(n))
            Console.WriteLine( "Yes");
        else
            Console.WriteLine("No");
    }
}
 
// This code is contributed by Ryuga

<?php
// PHP program to check if a number has
// same counts of 0s and 1s in every
// block.
 
// function to convert decimal to binary
function isEqualBlock($n)
{
    // Count same bits in last block
    $first_bit = $n % 2;
    $first_count = 1;
    $n = (int)($n / 2);
    while ($n % 2 == $first_bit && $n > 0)
    {
        $n = (int)($n / 2);
        $first_count++;
    }
 
    // If n is 0 or it has all 1s, then
    // it is not considered to have equal
    // number of 0s and 1s in blocks.
    if ($n == 0)
        return false;
 
    // Count same bits in all remaining blocks.
    while ($n > 0)
    {
        $first_bit = $n % 2;
        $curr_count = 1;
        $n = (int)($n / 2);
        while ($n % 2 == $first_bit)
        {
            $n = (int)($n / 2);
            $curr_count++;
        }
 
        if ($curr_count != $first_count)
            return false;
    }
 
    return true;
}
 
// Driver Code
$n = 51;
if (isEqualBlock($n))
    echo "Yes";
else
    echo "No";
 
// This code is contributed by
// Shivi_Aggarwal
?>

<script>
 
// javascript program to check if a number has
// same counts of 0s and 1s in every
// block.
 
// function to convert decimal to binary
function isEqualBlock(n)
{
    // Count same bits in last block
    var first_bit = n % 2;
    var first_count = 1;
    n = n / 2;
    while (n % 2 == first_bit && n > 0)
    {
        n = n / 2;
        first_count++;
    }
 
    // If n is 0 or it has all 1s,
    // then it is not considered to
    // have equal number of 0s and
    // 1s in blocks.
    if (n == 0)
        return false;
 
    // Count same bits in all remaining blocks.
    while (n > 0)
    {
 
        first_bit = n % 2;
        var curr_count = 1;
        n = n / 2;
        while (n % 2 == first_bit)
        {
            n = n / 2;
            curr_count++;
        }
 
        if (curr_count != first_count)
            return false;
    }
    return true;
}
 
// Driver code
var n = 51;
if (isEqualBlock(n))
    document.write( "Yes");
else
    document.write("No");
 
 
 
// This code contributed by shikhasingrajput
 
</script>

Yes