Given an array arr[] of size N. The task is to find the sum of the digits of all array elements which contains even number of 1’s in it’s their binary representation.
Examples:
Input : arr[] = {4, 9, 15}
Output : 15
4 = 10, it contains odd number of 1’s
9 = 1001, it contains even number of 1’s
15 = 1111, it contains even number of 1’s
Total Sum = Sum of digits of 9 and 15 = 9 + 1 + 5 = 15
Input : arr[] = {7, 23, 5}
Output :10
Approach :
The number of 1’s in the binary representation of each array element is counted and if it is even then the sum of its digits is calculated.
Below is the implementation of the above approach:
// CPP program to find Sum of digits with even // number of 1’s in their binary representation #include <bits/stdc++.h> using namespace std;
// Function to count and check the // number of 1's is even or odd int countOne( int n)
{ int count = 0;
while (n) {
n = n & (n - 1);
count++;
}
if (count % 2 == 0)
return 1;
else
return 0;
} // Function to calculate the sum // of the digits of a number int sumDigits( int n)
{ int sum = 0;
while (n != 0) {
sum += n % 10;
n /= 10;
}
return sum;
} // Driver Code int main()
{ int arr[] = { 4, 9, 15 };
int n = sizeof (arr) / sizeof (arr[0]);
int total_sum = 0;
// Iterate through the array
for ( int i = 0; i < n; i++) {
if (countOne(arr[i]))
total_sum += sumDigits(arr[i]);
}
cout << total_sum << '\n' ;
return 0;
} |
// Java program to find Sum of digits with even // number of 1's in their binary representation import java.util.*;
class GFG
{ // Function to count and check the // number of 1's is even or odd static int countOne( int n)
{ int count = 0 ;
while (n > 0 )
{
n = n & (n - 1 );
count++;
}
if (count % 2 == 0 )
return 1 ;
else
return 0 ;
} // Function to calculate the sum // of the digits of a number static int sumDigits( int n)
{ int sum = 0 ;
while (n != 0 )
{
sum += n % 10 ;
n /= 10 ;
}
return sum;
} // Driver Code public static void main(String[] args)
{ int arr[] = { 4 , 9 , 15 };
int n = arr.length;
int total_sum = 0 ;
// Iterate through the array
for ( int i = 0 ; i < n; i++)
{
if (countOne(arr[i]) == 1 )
total_sum += sumDigits(arr[i]);
}
System.out.println(total_sum);
} } // This code is contributed by 29AjayKumar |
# Python3 program to find Sum of digits with even # number of 1’s in their binary representation # Function to count and check the # number of 1's is even or odd def countOne(n):
count = 0
while (n):
n = n & (n - 1 )
count + = 1
if (count % 2 = = 0 ):
return 1
else :
return 0
# Function to calculate the summ # of the digits of a number def summDigits(n):
summ = 0
while (n ! = 0 ):
summ + = n % 10
n / / = 10
return summ
# Driver Code arr = [ 4 , 9 , 15 ]
n = len (arr)
total_summ = 0
# Iterate through the array for i in range (n):
if (countOne(arr[i])):
total_summ + = summDigits(arr[i])
print (total_summ )
# This code is contributed by Mohit Kumar |
// C# program to find Sum of digits with even // number of 1's in their binary representation using System;
class GFG
{ // Function to count and check the // number of 1's is even or odd static int countOne( int n)
{ int count = 0;
while (n > 0)
{
n = n & (n - 1);
count++;
}
if (count % 2 == 0)
return 1;
else
return 0;
} // Function to calculate the sum // of the digits of a number static int sumDigits( int n)
{ int sum = 0;
while (n != 0)
{
sum += n % 10;
n /= 10;
}
return sum;
} // Driver Code public static void Main()
{ int [] arr = { 4, 9, 15 };
int n = arr.Length;
int total_sum = 0;
// Iterate through the array
for ( int i = 0; i < n; i++)
{
if (countOne(arr[i]) == 1)
total_sum += sumDigits(arr[i]);
}
Console.WriteLine(total_sum);
} } // This code is contributed by Code_Mech |
<script> // Javascript program to find Sum of digits with even
// number of 1’s in their binary representation
// Function to count and check the
// number of 1's is even or odd
function countOne(n)
{
let count = 0;
while (n) {
n = n & (n - 1);
count++;
}
if (count % 2 == 0)
return 1;
else
return 0;
}
// Function to calculate the sum
// of the digits of a number
function sumDigits(n)
{
let sum = 0;
while (n != 0) {
sum += n % 10;
n = parseInt(n / 10, 10);
}
return sum;
}
let arr = [ 4, 9, 15 ];
let n = arr.length;
let total_sum = 0;
// Iterate through the array
for (let i = 0; i < n; i++) {
if (countOne(arr[i]))
total_sum += sumDigits(arr[i]);
}
document.write(total_sum);
</script> |
15
Approach#2: Using bin()
Traverse the array and check the binary representation of each element. If the count of 1’s in the binary representation of an element is even, add the sum of its digits to the answer variable. Return the answer variable.
Algorithm
1. Start with an answer variable set to 0.
2. Traverse the given array.
3. For each number in the array, convert it to binary using the in-built bin() function and remove the 0b prefix from the binary representation using the string slice binary[2:].
4. Count the number of ones in the binary representation of the current number using the string method count().
5. If the count of ones is even, add the sum of the digits of the current number to the answer variable using the sum() and map() functions.
6. Return the final answer variable.
#include <iostream> #include <vector> #include <bitset> // Function to calculate the sum of digits for numbers with an even count of binary ones int sumOfDigitsWithEvenOnes(std::vector< int > arr) {
int ans = 0;
// Loop through each number in the vector
for ( int num : arr) {
// Convert the number to binary and count the number of ones in its binary representation
std::bitset<32> binary(num);
int countOnes = binary.count();
// Check if the count of ones is even
if (countOnes % 2 == 0) {
int numCopy = num;
int digitSum = 0;
// Calculate the sum of digits for the current number
while (numCopy > 0) {
digitSum += numCopy % 10;
numCopy /= 10;
}
// Add the digit sum to the overall result
ans += digitSum;
}
}
// Return the final result
return ans;
} // Main function int main() {
// Initialize a vector of numbers
std::vector< int > arr = {4, 9, 15};
// Call the function and print the result
int result = sumOfDigitsWithEvenOnes(arr);
std::cout << result << std::endl;
// Return 0 to indicate successful execution
return 0;
} |
import java.util.ArrayList;
public class Main {
// Function to calculate the sum of digits for numbers
// with an even count of binary ones
static int
sumOfDigitsWithEvenOnes(ArrayList<Integer> arr)
{
int ans = 0 ;
// Loop through each number in the ArrayList
for ( int num : arr) {
// Convert the number to binary and count the
// number of ones in its binary representation
String binaryString
= Integer.toBinaryString(num);
int countOnes = Integer.bitCount(num);
// Check if the count of ones is even
if (countOnes % 2 == 0 ) {
int numCopy = num;
int digitSum = 0 ;
// Calculate the sum of digits for the
// current number
while (numCopy > 0 ) {
digitSum += numCopy % 10 ;
numCopy /= 10 ;
}
// Add the digit sum to the overall result
ans += digitSum;
}
}
// Return the final result
return ans;
}
// Main function
public static void main(String[] args)
{
// Initialize an ArrayList of numbers
ArrayList<Integer> arr = new ArrayList<>();
arr.add( 4 );
arr.add( 9 );
arr.add( 15 );
// Call the function and print the result
int result = sumOfDigitsWithEvenOnes(arr);
System.out.println(result);
}
} |
def sum_of_digits_with_even_ones(arr):
ans = 0
for num in arr:
binary = bin (num)[ 2 :]
count_ones = binary.count( '1' )
if count_ones % 2 = = 0 :
ans + = sum ( map ( int , str (num)))
return ans
arr = [ 4 , 9 , 15 ]
print (sum_of_digits_with_even_ones(arr))
|
using System;
using System.Collections.Generic;
class Program {
// Function to count set bits in an integer
static int CountSetBits( int num)
{
int count = 0;
while (num > 0) {
count += num & 1;
num >>= 1;
}
return count;
}
// Function to calculate the sum of digits for numbers
// with an even count of binary ones
static int SumOfDigitsWithEvenOnes(List< int > arr)
{
int ans = 0;
// Loop through each number in the list
foreach ( int num in arr)
{
// Count the number of ones in its binary
// representation
int countOnes = CountSetBits(num);
// Check if the count of ones is even
if (countOnes % 2 == 0) {
int numCopy = num;
int digitSum = 0;
// Calculate the sum of digits for the
// current number
while (numCopy > 0) {
digitSum += numCopy % 10;
numCopy /= 10;
}
// Add the digit sum to the overall result
ans += digitSum;
}
}
// Return the final result
return ans;
}
// Main function
static void Main()
{
// Initialize a list of numbers
List< int > arr = new List< int >{ 4, 9, 15 };
// Call the function and print the result
int result = SumOfDigitsWithEvenOnes(arr);
Console.WriteLine(result);
// Pause execution to see the result
Console.ReadLine();
}
} |
// Function to calculate the sum of digits for numbers with an even count of binary ones function sumOfDigitsWithEvenOnes(arr) {
let ans = 0;
// Loop through each number in the array
for (let num of arr) {
// Convert the number to binary and count the number of ones in its binary representation
let binary = num.toString(2);
let countOnes = (binary.match(/1/g) || []).length;
// Check if the count of ones is even
if (countOnes % 2 === 0) {
let numCopy = num;
let digitSum = 0;
// Calculate the sum of digits for the current number
while (numCopy > 0) {
digitSum += numCopy % 10;
numCopy = Math.floor(numCopy / 10);
}
// Add the digit sum to the overall result
ans += digitSum;
}
}
// Return the final result
return ans;
} // Main function function main() {
// Initialize an array of numbers
let arr = [4, 9, 15];
// Call the function and print the result
let result = sumOfDigitsWithEvenOnes(arr);
console.log(result);
} // Call the main function main(); |
15
Time complexity: O(N*M), where N is the length of the array and M is the maximum number of bits in any element of the array.
Space complexity: O(1).