GeeksforGeeks App
Open App
Browser
Continue

# 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 ``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

 ``

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

My Personal Notes arrow_drop_up