Sunday, October 12, 2025
HomeData Modelling & AICount array elements having sum of digits equal to K

Count array elements having sum of digits equal to K

Given an array arr[] of size N, the task is to count the number of array elements whose sum of digits is equal to K.

Examples:

Input: arr[] = {23, 54, 87, 29, 92, 62}, K = 11
Output: 2
Explanation: 
29 = 2 + 9 = 11
92 = 9 + 2 = 11

Input: arr[]= {11, 04, 57, 99, 98, 32}, K = 18
Output: 1

Approach: Follow the steps below to solve the problem:

  • Initialize a variable, say N, to store the size of the array.
  • Initialize a variable, say count, to store the elements having sum of digits equal to K.
  • Declare a function, sumOfDigits() to calculate the sum of digits of a number.
  • Traverse the array arr[] and for each array element, check if the sum of digits is equal to K or not. If found to be true, then increment count by 1.
  • Print the value of count as the required answer.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to calculate the
// sum of digits of the number N
int sumOfDigits(int N)
{
    // Stores the sum of digits
    int sum = 0;
    while (N != 0) {
        sum += N % 10;
        N /= 10;
    }
 
    // Return the sum
    return sum;
}
 
// Function to count array elements
int elementsHavingDigitSumK(int arr[], int N, int K)
{
    // Store the count of array
    // elements having sum of digits K
    int count = 0;
 
    // Traverse the array
    for (int i = 0; i < N; ++i) {
 
        // If sum of digits is equal to K
        if (sumOfDigits(arr[i]) == K) {
 
            // Increment the count
            count++;
        }
    }
 
    // Print the count
    cout << count;
}
 
// Driver Code
int main()
{
    // Given array
    int arr[] = { 23, 54, 87, 29, 92, 62 };
 
    // Given value of K
    int K = 11;
 
    // Size of the array
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function call to count array elements
    // having sum of digits equal to K
    elementsHavingDigitSumK(arr, N, K);
 
    return 0;
}


Java




// Java program for the above approach
public class GFG
{
     
    // Function to calculate the
    // sum of digits of the number N
    static int sumOfDigits(int N)
    {
       
        // Stores the sum of digits
        int sum = 0;
        while (N != 0) {
            sum += N % 10;
            N /= 10;
        }
       
        // Return the sum
        return sum;
    }
       
    // Function to count array elements
    static void elementsHavingDigitSumK(int[] arr, int N, int K)
    {
       
        // Store the count of array
        // elements having sum of digits K
        int count = 0;
       
        // Traverse the array
        for (int i = 0; i < N; ++i)
        {
       
            // If sum of digits is equal to K
            if (sumOfDigits(arr[i]) == K)
            {
       
                // Increment the count
                count++;
            }
        }
       
        // Print the count
        System.out.println(count);
    
 
  // Driver code
  public static void main(String args[])
  {
     
    // Given array
    int[] arr = { 23, 54, 87, 29, 92, 62 };
   
    // Given value of K
    int K = 11;
   
    // Size of the array
    int N = arr.length;
   
    // Function call to count array elements
    // having sum of digits equal to K
    elementsHavingDigitSumK(arr, N, K);
  }
}
 
// This code is contributed by AnkThon


Python3




# Python3 program for the above approach
 
# Function to calculate the
# sum of digits of the number N
def sumOfDigits(N) :
     
    # Stores the sum of digits
    sum = 0
    while (N != 0) :
        sum += N % 10
        N //= 10
     
    # Return the sum
    return sum
 
# Function to count array elements
def elementsHavingDigitSumK(arr, N, K) :
     
    # Store the count of array
    # elements having sum of digits K
    count = 0
 
    # Traverse the array
    for i in range(N):
 
        # If sum of digits is equal to K
        if (sumOfDigits(arr[i]) == K) :
 
            # Increment the count
            count += 1
 
    # Print the count
    print(count)
 
# Driver Code
 
# Given array
arr = [ 23, 54, 87, 29, 92, 62 ]
 
# Given value of K
K = 11
 
# Size of the array
N = len(arr)
 
# Function call to count array elements
# having sum of digits equal to K
elementsHavingDigitSumK(arr, N, K)
 
# This code is contributed by souravghosh0416.


C#




// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG {
     
    // Function to calculate the
    // sum of digits of the number N
    static int sumOfDigits(int N)
    {
       
        // Stores the sum of digits
        int sum = 0;
        while (N != 0) {
            sum += N % 10;
            N /= 10;
        }
       
        // Return the sum
        return sum;
    }
       
    // Function to count array elements
    static void elementsHavingDigitSumK(int[] arr, int N, int K)
    {
        // Store the count of array
        // elements having sum of digits K
        int count = 0;
       
        // Traverse the array
        for (int i = 0; i < N; ++i) {
       
            // If sum of digits is equal to K
            if (sumOfDigits(arr[i]) == K) {
       
                // Increment the count
                count++;
            }
        }
       
        // Print the count
        Console.WriteLine(count);
    
 
  // Driver code
  static void Main()
  {
     
    // Given array
    int[] arr = { 23, 54, 87, 29, 92, 62 };
   
    // Given value of K
    int K = 11;
   
    // Size of the array
    int N = arr.Length;
   
    // Function call to count array elements
    // having sum of digits equal to K
    elementsHavingDigitSumK(arr, N, K);
  }
}
 
// This code is contributed by divyeshrabadiya07.


Javascript




<script>
 
    // JavaScript program for the above approach
     
    // Function to calculate the
    // sum of digits of the number N
    function sumOfDigits(N)
    {
        
        // Stores the sum of digits
        let sum = 0;
        while (N != 0) {
            sum += N % 10;
            N = parseInt(N / 10, 10);
        }
        
        // Return the sum
        return sum;
    }
        
    // Function to count array elements
    function elementsHavingDigitSumK(arr, N, K)
    {
        // Store the count of array
        // elements having sum of digits K
        let count = 0;
        
        // Traverse the array
        for (let i = 0; i < N; ++i) {
        
            // If sum of digits is equal to K
            if (sumOfDigits(arr[i]) == K) {
        
                // Increment the count
                count++;
            }
        }
        
        // Print the count
        document.write(count);
    }
     
    // Given array
    let arr = [ 23, 54, 87, 29, 92, 62 ];
    
    // Given value of K
    let K = 11;
    
    // Size of the array
    let N = arr.length;
    
    // Function call to count array elements
    // having sum of digits equal to K
    elementsHavingDigitSumK(arr, N, K);
     
</script>


Output: 

2

 

Time Complexity: O(N * logN)
Auxiliary Space: O(1)

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!

RELATED ARTICLES

Most Popular

Dominic
32352 POSTS0 COMMENTS
Milvus
87 POSTS0 COMMENTS
Nango Kala
6720 POSTS0 COMMENTS
Nicole Veronica
11885 POSTS0 COMMENTS
Nokonwaba Nkukhwana
11942 POSTS0 COMMENTS
Shaida Kate Naidoo
6841 POSTS0 COMMENTS
Ted Musemwa
7105 POSTS0 COMMENTS
Thapelo Manthata
6797 POSTS0 COMMENTS
Umr Jansen
6795 POSTS0 COMMENTS