Scribd
Upload
80 views

Bitwise AND of The Sum of Prime Numbers and The Sum of Composite Numbers in An Array

The document describes a problem to find the bitwise AND of the sum of prime numbers and the sum of composite numbers in an array. It provides an efficient approach that uses the Sieve of Eratosthenes algorithm to first find all primes up to the maximum value in the array. It then traverses the array and calculates the sum of primes (S1) and sum of composites (S2). Finally, it returns the bitwise AND of S1 and S2. Pseudocode and C++/Python implementations of the approach are given. The time complexity is O(N*log(log(N))) and space complexity is O(max_val) where max_val is the maximum value in

Uploaded by

Krishanu Modak
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
80 views

Bitwise AND of The Sum of Prime Numbers and The Sum of Composite Numbers in An Array

The document describes a problem to find the bitwise AND of the sum of prime numbers and the sum of composite numbers in an array. It provides an efficient approach that uses the Sieve of Eratosthenes algorithm to first find all primes up to the maximum value in the array. It then traverses the array and calculates the sum of primes (S1) and sum of composites (S2). Finally, it returns the bitwise AND of S1 and S2. Pseudocode and C++/Python implementations of the approach are given. The time complexity is O(N*log(log(N))) and space complexity is O(max_val) where max_val is the maximum value in

Uploaded by

Krishanu Modak
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 3

Bitwise AND of the sum of prime numbers and the sum of composite numbers in
an array
Given an array of positive numbers, the task is to nd the bitwise AND of the sum of non-prime numbers and the sum of prime numbers. Note
that 1 is neither prime nor composite.

Examples:

Input: arr[] = {1, 3, 5, 10, 15, 7}


Output: 9
Sum of non-primes = 10 + 15 = 25
Sum of primes = 3 + 5 + 7 = 15
25 & 15 = 9

Input: arr[] = {3, 4, 6, 7}


Output: 10

Naive approach: A simple solution is to traverse the array and keep checking for every element if it is prime or not. If the number is prime, then
add it to S1 which stores the sum of prime numbers from the array else add it to S2 which stores the sum of non-prime numbers. Finally, print
S1 & S2.
Time complexity: O(N * sqrt(N))

E cient approach: Generate all the primes up to the maximum element of the array using the Sieve of Eratosthenes and store them in a hash.
Now, traverse the array and check if the number is prime or not. In the end, calculate and print the bitwise AND of the sum of prime numbers
and the sum of composite numbers.

Below is the implementation of the above approach:

C++
// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
  
// Function to return the bitwise AND of the
// sum of primes and the sum of non-primes
int calculateAND(int arr[], int n)
{
    // Find maximum value in the array
    int max_val = *max_element(arr, arr + n);
  
    // USE SIEVE TO FIND ALL PRIME NUMBERS LESS
    // THAN OR EQUAL TO max_val
    // Create a boolean array "prime[0..n]". A
    // value in prime[i] will finally be false
    // if i is Not a prime, else true.
    vector<bool> prime(max_val + 1, true);
  
    // Remaining part of SIEVE
    prime[0] = false;
    prime[1] = false;
    for (int p = 2; p * p <= max_val; p++) {
  
        // If prime[p] is not changed, then
        // it is a prime
        if (prime[p] == true) {
  
            // Update all multiples of p
            for (int i = p * 2; i <= max_val; i += p)
                prime[i] = false;
        }
    }
  
    // Store the sum of primes in S1 and
    // the sum of non-primes in S2
    int S1 = 0, S2 = 0;
    for (int i = 0; i < n; i++) {
  
        if (prime[arr[i]]) {
  
            // The number is prime
            S1 += arr[i];
        }
        else if (arr[i] != 1) {
  
            // The number is not prime
            S2 += arr[i];
        }
    }
  
    // Return the bitwise AND of the sums
    return (S1 & S2);
}
  
// Driver code
int main()
{
    int arr[] = { 3, 4, 6, 7 };
    int n = sizeof(arr) / sizeof(arr[0]);
  
    cout << calculateAND(arr, n);
  
    return 0;
}

Python3
# Python3 implementation of the approach
  
# Function to return the bitwise AND of the
# sum of primes and the sum of non-primes
def calculateAND(arr, n):
      
    # Find maximum value in the array
    max_val = max(arr)
   
    # USE SIEVE TO FIND ALL PRIME NUMBERS 
    # LESS THAN OR EQUAL TO max_val
    # Create a boolean array "prime[0..n]". 
    # A value in prime[i] will finally be false
    # if i is Not a prime, else true.
    prime = [True for i in range(max_val + 1)]
  
    # Remaining part of SIEVE
    prime[0] = False
    prime[1] = False
    for p in range(2, max_val + 1):
  
        if p * p >= max_val:
            break
  
        # If prime[p] is not changed, 
        # then it is a prime
        if (prime[p]):
  
            # Update all multiples of p
            for i in range(2 * p, max_val + 1, p):
                prime[i] = False
  
    # Store the sum of primes in S1 and
    # the sum of non-primes in S2
    S1 = 0
    S2 = 0
    for i in range(n):
  
        if (prime[arr[i]]):
  
            # The number is prime
            S1 += arr[i]
        elif (arr[i] != 1):
  
            # The number is not prime
            S2 += arr[i]
  
    # Return the bitwise AND of the sums
    return (S1 & S2)
  
# Driver code
arr = [3, 4, 6, 7]
n = len(arr)
  
print(calculateAND(arr, n))
  
# This code is contributed by Mohit Kumar

Output:
10

Time Complexity: O(N * log(log(N))


Space Complexity: O(max_val) where max_val is the maximum value of an element in the given array.

You might also like