Generate an array having Bitwise AND of the previous and the next element

Last Updated : 17 Sep, 2022

Given an array of integers arr[] of N elements, the task is to generate another array having (Bitwise) AND of previous and next elements with the following exceptions.

The first element is the bitwise AND of the first and the second element.
The last element is the bitwise AND of the last and the second last element.

Examples:

Input: arr[] = {1, 2, 3, 4, 5, 6}
Output: 0 1 0 1 4 4
The new array will be {1 & 2, 1 & 3, 2 & 4, 3 & 5, 4 & 6, 5 & 6}

Input: arr[] = {9, 8, 7}
Output: 8 1 0

Approach: The first and the second element of the new array can be calculated as arr[0] & arr[1] and arr[N - 1] & arr[N - 2] respectively. The rest of the elements can be calculated as arr[i - 1] & arr[i + 1].

Below is the implementation of the above approach:

C++

// C++ implementation of the approach
#include <iostream>
using namespace std;

// Function to generate the array that
// satisfies the given condition
void generateArr(int arr[], int n)
{

    // If there is only a single element
    // in the array
    if (n == 1) {
        cout << arr[0];
        return;
    }

    // To store the generated array
    int barr[n];

    // First element
    barr[0] = arr[0] & arr[1];

    // Last element
    barr[n - 1] = arr[n - 1] & arr[n - 2];

    // Rest of the elements
    for (int i = 1; i < n - 1; i++)
        barr[i] = arr[i - 1] & arr[i + 1];

    // Print the generated array
    for (int i = 0; i < n; i++)
        cout << barr[i] << " ";
}

// Driver code
int main()
{
    int arr[] = { 1, 2, 3, 4, 5, 6 };
    int n = sizeof(arr) / sizeof(arr[0]);

    generateArr(arr, n);

    return 0;
}

Java

// Java implementation of the approach
import java .io.*; 

class GFG 
{ 
static void generateArr(int[] arr, int n) 
{ 
    // Nothing to do when array size is 1 
    if (n <= 1) 
        return; 

    // store current value of arr[0] 
    // and update it 
    int prev = arr[0]; 
    arr[0] = arr[0] & arr[1]; 

    // Update rest of the array elements 
    for (int i = 1; i < n - 1; i++) 
    { 
        // Store current value of 
        // next interaction 
        int curr = arr[i]; 

        // Update current value using 
        // previous value 
        arr[i] = prev & arr[i + 1]; 

        // Update previous value 
        prev = curr; 
    } 

    // Update last array element separately 
    arr[n - 1] = prev & arr[n - 1]; 
} 

// Driver Code 
public static void main(String[] args) 
{ 
    int[] arr = { 1, 2, 3, 4, 5, 6 }; 
    int n = arr.length; 

    generateArr(arr, n); 

    // Print the modified array 
    for (int i = 0; i < n; i++) 
        System.out.print(arr[i] + " "); 
} 
} 

// This code is contributed by Nikhil

Python3

# Python3 implementation of the approach

# Function to generate the array that
# satisfies the given condition
def generateArr(arr, n):
    
    # If there is only a single element
    # in the array
    if (n == 1):
        print(arr[0]);
        return;

    # To store the generated array
    barr = [0] * n;

    # First element
    barr[0] = arr[0] & arr[1];

    # Last element
    barr[n - 1] = arr[n - 1] & arr[n - 2];

    # Rest of the elements
    for i in range(1, n - 1):
        barr[i] = arr[i - 1] & arr[i + 1];

    # Print the generated array
    for i in range(n):
        print(barr[i], end = " ");

# Driver Code
if __name__ == '__main__':
    arr = [1, 2, 3, 4, 5, 6];
    n = len(arr);

    generateArr(arr, n);

# This code is contributed by 29AjayKumar

// C# implementation of the approach
using System;
class GFG
{
static void generateArr(int[] arr, int n) 
{ 
    // Nothing to do when array size is 1 
    if (n <= 1) 
        return; 

    // store current value of arr[0] 
    // and update it 
    int prev = arr[0]; 
    arr[0] = arr[0] & arr[1]; 

    // Update rest of the array elements 
    for (int i = 1; i < n - 1; i++) 
    { 
        // Store current value of 
        // next interaction 
        int curr = arr[i]; 

        // Update current value using 
        // previous value 
        arr[i] = prev & arr[i + 1]; 

        // Update previous value 
        prev = curr; 
    } 

    // Update last array element separately 
    arr[n - 1] = prev & arr[n - 1]; 
} 

// Driver Code
static public void Main ()
{
    int[] arr = { 1, 2, 3, 4, 5, 6 }; 
    int n = arr.Length; 

    generateArr(arr, n); 

    // Print the modified array 
    for (int i = 0; i < n; i++) 
        Console.Write(arr[i] + " "); 
} 
} 

// This code is contributed by ajit.

JavaScript

<script>

    // Javascript implementation of the approach
    
    // Function to generate the array that 
    // satisfies the given condition 
    function generateArr(arr, n) 
    { 
      
        // If there is only a single element 
        // in the array 
        if (n == 1) { 
            document.write(arr[0]); 
            return; 
        } 
      
        // To store the generated array 
        let barr = new Array(n); 
      
        // First element 
        barr[0] = arr[0] & arr[1]; 
      
        // Last element 
        barr[n - 1] = arr[n - 1] & arr[n - 2]; 
      
        // Rest of the elements 
        for (let i = 1; i < n - 1; i++) 
            barr[i] = arr[i - 1] & arr[i + 1]; 
      
        // Print the generated array 
        for (let i = 0; i < n; i++) 
            document.write(barr[i] + " "); 
    } 
    
    let arr = [ 1, 2, 3, 4, 5, 6 ]; 
    let n = arr.length; 
  
    generateArr(arr, n); 

</script>

Output:

0 1 0 1 4 4

Time Complexity: O(N), where N is the size of the given array.
Auxiliary Space: O(N), where N is the size of the given array.

Generate an array having Bitwise AND of the previous and the next element

NikhilRathor

Improve

Article Tags :

Practice Tags :

Arrays

Generate an array having Bitwise AND of the previous and the next element

Similar Reads

Thank You!

What kind of Experience do you want to share?