Cuente los subarreglos formados por elementos que tienen exactamente K bits establecidos

Dada una array arr[] que consiste en N enteros y un entero K , la tarea es contar el número de subarreglos posibles que consisten en elementos que tienen exactamente K bits establecidos .

Ejemplos:

Entrada: arr[] = {4, 2, 1, 5, 6}, K = 2
Salida: 3
Explicación: Los subarreglos formados por elementos que tienen exactamente 2 bits establecidos son {5}, {6} y {5, 6 }.

Entrada: arr[] = {4, 2, 1, 5, 6}, K = 1
Salida: 6

Enfoque ingenuo: el enfoque más simple para resolver el problema es generar todos los subarreglos posibles del arreglo dado y contar esos subarreglos formados por elementos que tienen exactamente K bits establecidos. Finalmente, imprima el recuento de dichos subarreglos.

Complejidad de tiempo: O(N ³ log(M)), donde M es el elemento más grande de la array .
Espacio Auxiliar: O(1)

Enfoque eficiente: la idea es realizar un seguimiento de los elementos de array consecutivos con K bits establecidos y encontrar el recuento de subarreglos con esos conjuntos de elementos consecutivos. Siga los pasos a continuación para resolver el problema:

Inicialice una variable, digamos res como 0 , para almacenar el recuento total de subarreglos que consisten en elementos que tienen K bits establecidos . Inicialice una variable, digamos contar como 0 , para almacenar el recuento de un conjunto consecutivo de elementos que tienen K bits establecidos.
Recorra la array dada arr[] y realice los siguientes pasos:
- Si el elemento actual arr[i] tiene K bits establecidos , entonces incremente el conteo en 1 .
- De lo contrario, incremente el valor de res en (count*(count – 1)) / 2 como el número total de subarreglos formados por los elementos consecutivos anteriores y establezca count en 0 .
Después de completar los pasos anteriores, imprima el valor de res como el recuento resultante de subarreglos.

A continuación se muestra la implementación del enfoque anterior:

C++

// C++ program for the above approach
#include <iostream>
using namespace std;
 
// Function to count the number
// of set bits in an integer N
int countSet(int N)
{
 
  // Stores the count of set bits
  int ans = 0;
 
  // While N is non-zero
  while(N)
  {
 
    // If the LSB is 1, then
    // increment ans by 1
    ans += N & 1;
    N >>= 1;
  }
 
  // Return the total set bits
  return ans;
}
 
// Function to count the number of
// subarrays having made up of
// elements having K set bits
int countSub(int *arr,int k)
{
 
  // Stores the total count of
  // resultant subarrays
  int ans = 0;
  int setK = 0;
 
  // Traverse the given array
  for(int i = 0; i < 5; i++)
  {
 
    // If the current element
    // has K set bits
    if(countSet(arr[i]) == k)
      setK += 1;
 
    // Otherwise
    else
      setK = 0;
 
    // Increment count of subarrays
    ans += setK;
  }
 
  // Return total count of subarrays
  return ans;
}
 
// Driver Code
int main()
{
  int arr[] = {4, 2, 1, 5, 6};
  int K = 2;
 
  // Function Call
  cout<<(countSub(arr, K));
  return 0;
}
 
// This code is contributed by rohitsingh07052.

Java

// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Function to count the number
// of set bits in an integer N
static int countSet(int N)
{
     
    // Stores the count of set bits
    int ans = 0;
     
    // While N is non-zero
    while(N > 0)
    {
         
        // If the LSB is 1, then
        // increment ans by 1
        ans += N & 1;
        N >>= 1;
    }
     
    // Return the total set bits
    return ans;
}
 
// Function to count the number of
// subarrays having made up of
// elements having K set bits
static int countSub(int []arr,int k)
{
     
    // Stores the total count of
    // resultant subarrays
    int ans = 0;
    int setK = 0;
     
    // Traverse the given array
    for(int i = 0; i < 5; i++)
    {
     
        // If the current element
        // has K set bits
        if (countSet(arr[i]) == k)
            setK += 1;
         
        // Otherwise
        else
            setK = 0;
         
        // Increment count of subarrays
        ans += setK;
    }
     
    // Return total count of subarrays
    return ans;
}
 
// Driver Code
public static void main(String[] args)
{
    int arr[] = {4, 2, 1, 5, 6};
    int K = 2;
     
    // Function Call
    System.out.print(countSub(arr, K));
}
}
 
// This code is contributed by 29AjayKumar

Python3

# Python3 program for the above approach
 
# Function to count the number
# of set bits in an integer N
def countSet(N):
 
    # Stores the count of set bits
    ans = 0
 
    # While N is non-zero
    while N:
 
        # If the LSB is 1, then
        # increment ans by 1
        ans += N & 1
        N >>= 1
 
    # Return the total set bits
    return ans
 
# Function to count the number of
# subarrays having made up of
# elements having K set bits
def countSub(arr, k):
 
    # Stores the total count of
    # resultant subarrays
    ans = 0
    setK = 0
 
    # Traverse the given array
    for i in arr:
 
        # If the current element
        # has K set bits
        if countSet(i) == k:
            setK += 1
 
        # Otherwise
        else:
            setK = 0
 
        # Increment count of subarrays
        ans += setK
 
    # Return total count of subarrays
    return ans
 
 
# Driver Code
arr = [4, 2, 1, 5, 6]
K = 2
 
# Function Call
print(countSub(arr, K))

C#

// C# program for the above approach
using System;
 
class GFG {
 
  // Function to count the number
  // of set bits in an integer N
  static int countSet(int N)
  {
 
    // Stores the count of set bits
    int ans = 0;
 
    // While N is non-zero
    while (N > 0)
    {
 
      // If the LSB is 1, then
      // increment ans by 1
      ans += N & 1;
      N >>= 1;
    }
 
    // Return the total set bits
    return ans;
  }
 
  // Function to count the number of
  // subarrays having made up of
  // elements having K set bits
  static int countSub(int[] arr, int k)
  {
 
    // Stores the total count of
    // resultant subarrays
    int ans = 0;
    int setK = 0;
 
    // Traverse the given array
    for (int i = 0; i < 5; i++) {
 
      // If the current element
      // has K set bits
      if (countSet(arr[i]) == k)
        setK += 1;
 
      // Otherwise
      else
        setK = 0;
 
      // Increment count of subarrays
      ans += setK;
    }
 
    // Return total count of subarrays
    return ans;
  }
 
  // Driver Code
  public static void Main(string[] args)
  {
    int[] arr = { 4, 2, 1, 5, 6 };
    int K = 2;
 
    // Function Call
    Console.WriteLine(countSub(arr, K));
  }
}
 
// This code is contributed by ukasp.

Javascript

<script>
 
// JavaScript program for the above approach
 
// Function to count the number
// of set bits in an integer N
function countSet(N)
{
 
// Stores the count of set bits
let ans = 0;
 
// While N is non-zero
while(N)
{
 
    // If the LSB is 1, then
    // increment ans by 1
    ans += N & 1;
    N >>= 1;
}
 
// Return the total set bits
return ans;
}
 
// Function to count the number of
// subarrays having made up of
// elements having K set bits
function countSub(arr,k)
{
 
// Stores the total count of
// resultant subarrays
let ans = 0;
let setK = 0;
 
// Traverse the given array
for(let i = 0; i < 5; i++)
{
 
    // If the current element
    // has K set bits
    if(countSet(arr[i]) == k)
    setK += 1;
 
    // Otherwise
    else
    setK = 0;
 
    // Increment count of subarrays
    ans += setK;
}
 
// Return total count of subarrays
return ans;
}
 
// Driver Code
 
let arr = [4, 2, 1, 5, 6];
let K = 2;
 
// Function Call
document.write((countSub(arr, K)));
 
// This code is contributed by Mayank Tyagi
</script>

Producción:

Complejidad de tiempo: O(N*log(M)), donde M es el elemento más grande de la array .
Espacio Auxiliar: O(1)

Publicación traducida automáticamente

Artículo escrito por rohitsingh07052 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

C++

Java

Python3

C#

Javascript

Deja una respuesta Cancelar la respuesta