AND bit a bit de todos los pares no ordenados de una array dada

Posted on by Rudeus Greyrat

Dada una array arr[] de tamaño N , la tarea es encontrar el AND bit a bit de todos los posibles pares no ordenados presentes en la array dada.

Ejemplos:

Entrada: arr[] = {1, 5, 3, 7}
Salida: 1 
Explicación: 
Todos los pares desordenados posibles son (1, 5), (1, 3), (1, 7), (5, 3), ( 5, 7), (3, 7). 
Y bit a bit de todos los pares posibles = ( 1 y 5 ) y ( 1 y 3 ) y ( 1 y 7 ) y ( 5 y 3 ) y ( 5 y 7 ) y ( 3 y 7 ) 
                                                         = 1 y 1 y 1 y 1 & 5 & 3 
                                                         = 1 
Por lo tanto, la salida requerida es 1.

Entrada: arr[] = {4, 5, 12, 15}
Salida: 4

Enfoque ingenuo: la idea es atravesar la array y generar todos los pares posibles de la array dada . Finalmente, imprima AND bit a bit de cada elemento presente en estos pares de la array dada. Siga los pasos a continuación para resolver el problema:

  • Inicialice una variable, digamos totalAND , para almacenar Bitwise AND de cada elemento de estos pares.
  • Iterar sobre la array y generar todos los pares posibles ( arr[i], arr[j] ) a partir de la array dada.
  • Para cada par ( arr[i], arr[j] ), actualice el valor de totalAND = (totalAND & arr[i] & arr[j]) .
  • Finalmente, imprima el valor de totalAND .

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

C++

// C++ program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to calculate bitwise AND
// of all pairs from the given array
int TotalAndPair(int arr[], int N)
{
    // Stores bitwise AND
    // of all possible pairs
    int totalAND = (1 << 30) - 1;
 
    // Generate all possible pairs
    for (int i = 0; i < N; i++) {
        for (int j = i + 1; j < N;
             j++) {
 
            // Calculate bitwise AND
            // of each pair
            totalAND &= arr[i]
                        & arr[j];
        }
    }
    return totalAND;
}
 
// Driver Code
int main()
{
    int arr[] = { 4, 5, 12, 15 };
    int N = sizeof(arr) / sizeof(arr[0]);
    cout << TotalAndPair(arr, N);
}

Java

// Java program to implement
// the above approach
import java.util.*;
 
class GFG{
 
// Function to calculate bitwise AND
// of all pairs from the given array
static int TotalAndPair(int arr[], int N)
{
    // Stores bitwise AND
    // of all possible pairs
    int totalAND = (1 << 30) - 1;
 
    // Generate all possible pairs
    for (int i = 0; i < N; i++)
    {
        for (int j = i + 1; j < N;
             j++)
        {
 
            // Calculate bitwise AND
            // of each pair
            totalAND &= arr[i]
                        & arr[j];
        }
    }
    return totalAND;
}
 
// Driver Code
public static void main(String[] args)
{
    int arr[] = { 4, 5, 12, 15 };
    int N = arr.length;
    System.out.print(TotalAndPair(arr, N));
}
}
 
// This code is contributed by shikhasingrajput

Python3

# Python3 program to implement
# the above approach
 
# Function to calculate bitwise AND
# of all pairs from the given array
def TotalAndPair(arr, N):
 
  # Stores bitwise AND
  # of all possible pairs
    totalAND = (1 << 30) - 1
 
    # Generate all possible pairs
    for i in range(N):
        for j in range(i + 1, N):
 
            # Calculate bitwise AND
            # of each pair
            totalAND &= (arr[i] & arr[j])
    return totalAND
 
# Driver Code
if __name__ == '__main__':
    arr=[4, 5, 12, 15]
    N = len(arr)
    print(TotalAndPair(arr, N))
 
# This code is contributed by mohit kumar 29

C#

// C# program to implement
// the above approach 
using System;
  
class GFG{
  
// Function to calculate bitwise AND
// of all pairs from the given array
static int TotalAndPair(int[] arr, int N)
{
     
    // Stores bitwise AND
    // of all possible pairs
    int totalAND = (1 << 30) - 1;
  
    // Generate all possible pairs
    for(int i = 0; i < N; i++)
    {
        for(int j = i + 1; j < N; j++)
        {
             
            // Calculate bitwise AND
            // of each pair
            totalAND &= arr[i] & arr[j];
        }
    }
    return totalAND;
}
  
// Driver Code
public static void Main()
{
    int[] arr = { 4, 5, 12, 15 };
    int N = arr.Length;
     
    Console.Write(TotalAndPair(arr, N));
}
}
 
// This code is contributed by sanjoy_62

Javascript

<script>
 
// JavaScript program to implement
// the above approach
 
// Function to calculate bitwise AND
// of all pairs from the given array
function TotalAndPair(arr, N)
{
    // Stores bitwise AND
    // of all possible pairs
    let totalAND = (1 << 30) - 1;
 
    // Generate all possible pairs
    for (let i = 0; i < N; i++) {
        for (let j = i + 1; j < N;
            j++) {
 
            // Calculate bitwise AND
            // of each pair
            totalAND &= arr[i]
                        & arr[j];
        }
    }
    return totalAND;
}
 
// Driver Code
    let arr = [ 4, 5, 12, 15 ];
    let N = arr.length;
    document.write(TotalAndPair(arr, N));
 
 
// This code is contributed by Surbhi Tyagi
 
</script>
Producción: 

4

 

Complejidad de Tiempo: O(N 2 )
Espacio Auxiliar: O(1)

Enfoque eficiente: el enfoque anterior se puede optimizar en función de las siguientes observaciones:

  • Teniendo en cuenta una array de 4 elementos, Bitwise AND requerido es el siguiente:

(arr[0] & arr[1]) & (arr[0] & arr[2]) & (arr[0] & arr[3]) & (arr[1] & arr[2]) & (arr [1] & salida[3]) & (salida[2] & salida[3]) 
 

(arr[0] & arr[0] & arr[0]) & (arr[1] & arr[1] & arr[1]) & (arr[2] & arr[2] & arr[2]) & (arr[3] & arr[3] & arr[3]) 
 

  • Se puede observar que cada elemento del arreglo ocurre exactamente (N – 1) veces en todos los pares posibles.
  • Según la propiedad X & X = X de los operadores AND bit a bit , la expresión anterior se puede reorganizar a arr[0] & arr[1] & arr[2] & arr[3] , que es igual al AND bit a bit de todos elementos del arreglo original .

Siga los pasos a continuación para resolver el problema: 

  • Inicialice una variable totalAND para almacenar el resultado.
  • Recorre la array dada .
  • Calcule AND bit a bit de todos los pares no ordenados actualizando totalAND = totalAND & arr[i] .

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

C++

// C++ program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to calculate bitwise AND
// of all pairs from the given array
int TotalAndPair(int arr[], int N)
{
    // Stores bitwise AND
    // of all possible pairs
    int totalAND = (1 << 30) - 1;
 
    // Iterate over the array arr[]
    for (int i = 0; i < N; i++) {
 
        // Calculate bitwise AND
        // of each array element
        totalAND &= arr[i];
    }
    return totalAND;
}
 
// Driver Code
int main()
{
    int arr[] = { 4, 5, 12, 15 };
    int N = sizeof(arr) / sizeof(arr[0]);
    cout << TotalAndPair(arr, N);
}

Java

// Java program to implement
// the above approach
 
import java.util.*;
 
class GFG{
 
// Function to calculate bitwise AND
// of all pairs from the given array
static int TotalAndPair(int arr[], int N)
{
    // Stores bitwise AND
    // of all possible pairs
    int totalAND = (1 << 30) - 1;
 
    // Iterate over the array arr[]
    for (int i = 0; i < N; i++) {
 
        // Calculate bitwise AND
        // of each array element
        totalAND &= arr[i];
    }
    return totalAND;
}
 
// Driver Code
public static void main(String[] args)
{
    int arr[] = { 4, 5, 12, 15 };
    int N = arr.length;
    System.out.print(TotalAndPair(arr, N));
}
}
 
// This code is contributed by 29AjayKumar

Python3

# Python program to implement
# the above approach
 
# Function to calculate bitwise AND
# of all pairs from the given array
def TotalAndPair(arr, N):
   
    # Stores bitwise AND
    # of all possible pairs
    totalAND = (1 << 30) - 1;
 
    # Iterate over the array arr
    for i in range(N):
       
        # Calculate bitwise AND
        # of each array element
        totalAND &= arr[i];
 
    return totalAND;
 
# Driver Code
if __name__ == '__main__':
    arr = [4, 5, 12, 15];
    N = len(arr);
    print(TotalAndPair(arr, N));
     
    # This code is contributed by 29AjayKumar

C#

// C# program to implement
// the above approach
using System;
 
class GFG{
 
// Function to calculate bitwise AND
// of all pairs from the given array
static int TotalAndPair(int []arr, int N)
{
     
    // Stores bitwise AND
    // of all possible pairs
    int totalAND = (1 << 30) - 1;
     
    // Iterate over the array arr[]
    for(int i = 0; i < N; i++)
    {
         
        // Calculate bitwise AND
        // of each array element
        totalAND &= arr[i];
    }
    return totalAND;
}
 
// Driver Code
public static void Main(String[] args)
{
    int []arr = { 4, 5, 12, 15 };
    int N = arr.Length;
     
    Console.Write(TotalAndPair(arr, N));
}
}
 
// This code is contributed by AnkThon

Javascript

<script>
// JavaScript program to implement
// the above approach
 
// Function to calculate bitwise AND
// of all pairs from the given array
function TotalAndPair(arr, N)
{
    // Stores bitwise AND
    // of all possible pairs
    let totalAND = (1 << 30) - 1;
 
    // Iterate over the array arr[]
    for (let i = 0; i < N; i++) {
 
        // Calculate bitwise AND
        // of each array element
        totalAND &= arr[i];
    }
    return totalAND;
}
 
// Driver Code
 
    let arr = [ 4, 5, 12, 15 ];
    let N = arr.length;
    document.write(TotalAndPair(arr, N));
 
 
// This code is contributed by Surbhi Tyagi.
</script>
Producción: 

4

 

Complejidad temporal : O(N)
Espacio auxiliar: O(1)

Publicación traducida automáticamente

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

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *