Sum of array elements which are multiples of a given number

Given an array arr[] consisting of positive integers and an integer N, the task is to find the sum of all array elements which are multiples of N

Examples:

Input: arr[] = {1, 2, 3, 5, 6}, N = 3
Output: 9
Explanation: From the given array, 3 and 6 are multiples of 3. Therefore, sum = 3 + 6 = 9.

Input: arr[] = {1, 2, 3, 5, 7, 11, 13}, N = 5
Output: 5

Approach: The idea is to traverse the array and for each array element, check if it is a multiple of N or not and add those elements. Follow the steps below to solve the problem:

1. Initialize a variable, say sum, to store the required sum.
2. Traverse the given array and for each array element, perform the following operations.
3. Check whether the array element is a multiple of N or not.
4. If the element is a multiple of N, then add the element to sum.
5. Finally, print the value of sum.

Below is the implementation of the above approach:

C++

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to find the sum of array
// elements which are multiples of N
void mulsum(int arr[], int n, int N)
{

    // Stores the sum
    int sum = 0;

    // Traverse the given array
    for (int i = 0; i < n; i++) {

        // If current element
        // is a multiple of N
        if (arr[i] % N == 0) {
            sum = sum + arr[i];
        }
    }

    // Print total sum
    cout << sum;
}

// Driver Code
int main()
{

    // Given arr[]
    int arr[] = { 1, 2, 3, 5, 6 };

    int n = sizeof(arr) / sizeof(arr[0]);

    int N = 3;

    mulsum(arr, n, N);

    return 0;
}

Java

// Java program for the above approach
import java.io.*;
import java.util.*;
class GFG{

// Function to find the sum of array
// elements which are multiples of N
static void mulsum(int arr[], int n, int N)
{

    // Stores the sum
    int sum = 0;

    // Traverse the given array
    for (int i = 0; i < n; i++)
    {

        // If current element
        // is a multiple of N
        if (arr[i] % N == 0)
        {
            sum = sum + arr[i];
        }
    }

    // Print total sum
    System.out.println(sum);
}


// Driver Code
public static void main(String[] args)
{

    // Given arr[]
    int arr[] = { 1, 2, 3, 5, 6 };
    int n = arr.length;
    int N = 3;
    mulsum(arr, n, N);
}
}

// This code is contributed by jana_sayantan.

Python

# Python3 program for the above approach

# Function to find the sum of array
# elements which are multiples of N
def mulsum(arr, n, N):

    # Stores the sum
    sums = 0

    # Traverse the array
    for i in range(0, n):
        if arr[i] % N == 0:
              sums = sums + arr[i]

    # Print total sum
    print(sums)

# Driver Code
if __name__ == "__main__":

    # Given arr[]
    arr = [ 1, 2, 3, 5, 6 ]

    n = len(arr)

    N = 3

    # Function call
    mulsum(arr, n, N)

C#

// C# program for the above approach
using System;
public class GFG
{

// Function to find the sum of array
// elements which are multiples of N
static void mulsum(int[] arr, int n, int N)
{

    // Stores the sum
    int sum = 0;

    // Traverse the given array
    for (int i = 0; i < n; i++)
    {

        // If current element
        // is a multiple of N
        if (arr[i] % N == 0)
        {
            sum = sum + arr[i];
        }
    }

    // Print total sum
    Console.Write(sum);
}

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

// This code is contributed by Dharanendra L V.

Javascript

<script>

// JavaScript program for the above approach

// Function to find the sum of array
// elements which are multiples of N
function mulsum(arr, n, N)
{

    // Stores the sum
    var sum = 0;

    // Traverse the given array
    for(var i = 0; i < n; i++)
    {

        // If current element
        // is a multiple of N
        if (arr[i] % N == 0)
        {
            sum = sum + arr[i];
        }
    }

    // Print total sum
    document.write(sum);
}

// Driver Code

// Given arr[]
var arr = [ 1, 2, 3, 5, 6 ];
var n = arr.length;
var N = 3;

mulsum(arr, n, N);

// This code is contributed by rdtank

</script>

Output:

9

Time Complexity: O(N) since one traversal of the array is required to complete all operations hence the overall time required by the algorithm is linear
Auxiliary Space: O(1) since no extra array is used so the space taken by the algorithm is constant