Related Articles

# Sum of array elements possible by appending arr[i] / K to the end of the array K times for array elements divisible by K

• Last Updated : 28 Jun, 2021

Given an array arr[] consisting of N integers and an integer K, the task is to find the sum of the array elements possible by traversing the array and adding arr[i] / K, K number of times at the end of the array, if arr[i] is divisible by K. Otherwise, stop the traversal.

Examples:

Input: arr[] = {4, 6, 8, 2}, K = 2
Output: 44
Explanation:
The following operations are performed:

1. For arr(= 4): arr(= 4) is divisible by 2, therefore append 4/2 = 2, 2 numbers of times at the end of the array. Now, the array modifies to {4, 6, 8, 2, 2, 2}.
2. For arr(= 6): arr(= 6) is divisible by 2, therefore append 6/2 = 3, 2 number of times at the end of the array. Now, the array modifies to {4, 6, 8, 2, 2, 2, 3, 3}.
3. For arr(= 8): arr(= 8) is divisible by 2, therefore append 8/2 = 4, 2 number of times at the end of the array. Now, the array modifies to {4, 6, 8, 2, 2, 2, 3, 3, 4, 4}.
4. For arr(= 2): arr(= 2) is divisible by 2, therefore append 2/2 = 1, 2 number of times at the end of the array. Now, the array modifies to {4, 6, 8, 2, 2, 2, 3, 3, 4, 4, 1, 1}.
5. For arr(= 2): arr(= 2) is divisible by 2, therefore append 2/2 = 1, 2 number of times at the end of the array. Now, the array modifies to {4, 6, 8, 2, 2, 2, 3, 3, 4, 4, 1, 1, 1, 1}.
6. For arr(= 2): arr(= 2) is divisible by 2, therefore append 2/2 = 1, 2 number of times at the end of the array. Now, the array modifies to {4, 6, 8, 2, 2, 2, 3, 3, 4, 4, 1, 1, 1, 1, 1, 1}.

After completing the above steps, the sum of the array elements is = 4 + 6 + 8 + 2 + 2 + 2 + 3 + 3 + 4 + 4 + 1 + 1 + 1 + 1 + 1 + 1 = 44.

Input: arr[] = {4, 6, 8, 9}, K = 2
Output: 45

Naive Approach: The simplest approach is to solve the given problem is to traverse the given array and add the value (arr[i]/K) K a number of times at the end of the array. After completing the above steps, print the sum of the array elements.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to calculate sum of array``// elements after adding arr[i] / K``// to the end of the array if arr[i]``// is divisible by K``int` `sum(``int` `arr[], ``int` `N, ``int` `K)``{``    ``// Stores the sum of the array``    ``int` `sum = 0;` `    ``vector<``long` `long``> v;` `    ``// Traverse the array arr[]``    ``for` `(``int` `i = 0; i < N; i++) {``        ``v.push_back(arr[i]);``    ``}` `    ``// Traverse the vector``    ``for` `(``int` `i = 0;``         ``i < v.size(); i++) {` `        ``// If v[i] is divisible by K``        ``if` `(v[i] % K == 0) {` `            ``long` `long` `x = v[i] / K;` `            ``// Iterate over the range``            ``// [0, K]``            ``for` `(``int` `j = 0; j < K; j++) {``                ``// Update v``                ``v.push_back(x);``            ``}``        ``}``        ``// Otherwise``        ``else``            ``break``;``    ``}` `    ``// Traverse the vector v``    ``for` `(``int` `i = 0; i < v.size(); i++)``        ``sum = sum + v[i];` `    ``// Return the sum of the updated array``    ``return` `sum;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 4, 6, 8, 2 };``    ``int` `K = 2;``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``cout << sum(arr, N, K);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.lang.*;``import` `java.util.*;` `class` `GFG{` `// Function to calculate sum of array``// elements after adding arr[i] / K``// to the end of the array if arr[i]``// is divisible by K``static` `int` `sum(``int` `arr[], ``int` `N, ``int` `K)``{``    ` `    ``// Stores the sum of the array``    ``int` `sum = ``0``;` `    ``ArrayList v = ``new` `ArrayList<>();` `    ``// Traverse the array arr[]``    ``for``(``int` `i = ``0``; i < N; i++)``    ``{``        ``v.add(arr[i]);``    ``}` `    ``// Traverse the vector``    ``for``(``int` `i = ``0``; i < v.size(); i++)``    ``{``        ` `        ``// If v[i] is divisible by K``        ``if` `(v.get(i) % K == ``0``)``        ``{``            ``int` `x = v.get(i) / K;` `            ``// Iterate over the range``            ``// [0, K]``            ``for``(``int` `j = ``0``; j < K; j++)``            ``{``                ` `                ``// Update v``                ``v.add(x);``            ``}``        ``}``        ` `        ``// Otherwise``        ``else``            ``break``;``    ``}` `    ``// Traverse the vector v``    ``for``(``int` `i = ``0``; i < v.size(); i++)``        ``sum = sum + v.get(i);` `    ``// Return the sum of the updated array``    ``return` `sum;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``4``, ``6``, ``8``, ``2` `};``    ``int` `K = ``2``;``    ``int` `N = arr.length;``    ` `    ``System.out.println(sum(arr, N, K));``}``}` `// This code is contributed by Kingash`

## Python3

 `# Python3 program for the above approach` `# Function to calculate sum of array``# elements after adding arr[i] / K``# to the end of the array if arr[i]``# is divisible by K``def` `summ(arr, N, K):``    ` `    ``# Stores the sum of the array``    ``sum` `=` `4` `    ``v ``=` `[i ``for` `i ``in` `arr]` `    ``# Traverse the vector``    ``for` `i ``in` `range``(``len``(v)):` `        ``# If v[i] is divisible by K``        ``if` `(v[i] ``%` `K ``=``=` `0``):` `            ``x ``=` `v[i] ``/``/` `K``            ` `            ``# Iterate over the range``            ``# [0, K]``            ``for` `j ``in` `range``(K):``                ` `                ``# Update v``                ``v.append(x)``                ` `        ``# Otherwise``        ``else``:``            ``break``        ` `    ``# Traverse the vector v``    ``for` `i ``in` `range``(``len``(v)):``        ``sum` `=` `sum` `+` `v[i]` `    ``# Return the sum of the updated array``    ``return` `sum` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``arr ``=` `[ ``4``, ``6``, ``8``, ``2` `]``    ``K ``=` `2``    ``N ``=` `len``(arr)``    ` `    ``print``(summ(arr, N, K))` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;``class` `GFG {` `    ``// Function to calculate sum of array``    ``// elements after adding arr[i] / K``    ``// to the end of the array if arr[i]``    ``// is divisible by K``    ``static` `int` `sum(``int``[] arr, ``int` `N, ``int` `K)``    ``{` `        ``// Stores the sum of the array``        ``int` `sum = 0;` `        ``List<``int``> v = ``new` `List<``int``>();` `        ``// Traverse the array arr[]``        ``for` `(``int` `i = 0; i < N; i++) {``            ``v.Add(arr[i]);``        ``}` `        ``// Traverse the vector``        ``for` `(``int` `i = 0; i < v.Count; i++) {` `            ``// If v[i] is divisible by K``            ``if` `(v[i] % K == 0) {``                ``int` `x = v[i] / K;` `                ``// Iterate over the range``                ``// [0, K]``                ``for` `(``int` `j = 0; j < K; j++) {` `                    ``// Update v``                    ``v.Add(x);``                ``}``            ``}` `            ``// Otherwise``            ``else``                ``break``;``        ``}` `        ``// Traverse the vector v``        ``for` `(``int` `i = 0; i < v.Count; i++)``            ``sum = sum + v[i];` `        ``// Return the sum of the updated array``        ``return` `sum;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``int``[] arr = { 4, 6, 8, 2 };``        ``int` `K = 2;``        ``int` `N = arr.Length;` `        ``Console.WriteLine(sum(arr, N, K));``    ``}``}` `// This code is contributed by ukasp.`

## Javascript

 ``
Output:
`44`

Time Complexity: O(N * K * log N)
Auxiliary Space: O(M), M is the maximum element of the array.

Efficient Approach: The above approach can also be optimized based on the following observations:

• If arr[i] is divisible by K, then adding arr[i] / K, K times increases the sum by arr[i].
• Therefore, the idea is to only push the arr[i] / K only once at the end of the vector.

Follow the steps below to solve the problem:

• Initialize a variable, say sum as 0 that stores the sum of all the array elements array A[].
• Initialize an array, say A[] and store all the array elements arr[] in A[].
• Initialize a variable, say flag as 0 that stores whether the element is to be added at the end of the array or not.
• Traverse the array A[] and perform the following steps:
• If the value flag is 0 and A[i] is divisible by K, then push A[i] at the end of V.
• Otherwise, update the value of flag as 1.
• Increment the value of the sum by V[i % N].
• After completing the above steps, print the value of the sum as the resultant sum.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to calculate sum of array``// elements after adding arr[i] / K``// to the end of the array if arr[i]``// is divisible by K``int` `sum(``int` `arr[], ``int` `N, ``int` `K)``{``    ``// Stores the sum of the array``    ``int` `sum = 0;` `    ``// Stores the array elements``    ``vector<``int``> v;` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < N; i++) {``        ``v.push_back(arr[i]);``    ``}` `    ``// Stores if the operation``    ``// should be formed or not``    ``bool` `flag = 0;` `    ``// Traverse the vector V``    ``for` `(``int` `i = 0; i < v.size(); i++) {` `        ``// If flag is false and if``        ``// v[i] is divisible by K``        ``if` `(!flag && v[i] % K == 0)``            ``v.push_back(v[i] / K);` `        ``// Otherwise, set flag as true``        ``else` `{``            ``flag = 1;``        ``}` `        ``// Increment the sum by v[i % N]``        ``sum = sum + v[i % N];``    ``}` `    ``// Return the resultant sum``    ``return` `sum;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 4, 6, 8, 2 };``    ``int` `K = 2;``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``cout << sum(arr, N, K);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach` `import` `java.io.*;``import` `java.util.*;` `class` `GFG {``  ` `      ``// Function to calculate sum of array``    ``// elements after adding arr[i] / K``    ``// to the end of the array if arr[i]``    ``// is divisible by K``    ``static` `int` `sum(``int` `arr[], ``int` `N, ``int` `K)``    ``{``        ``// Stores the sum of the array``        ``int` `sum = ``0``;` `        ``// Stores the array elements``        ``ArrayList v = ``new` `ArrayList();` `        ``// Traverse the array``        ``for` `(``int` `i = ``0``; i < N; i++) {``            ``v.add(arr[i]);``        ``}` `        ``// Stores if the operation``        ``// should be formed or not``        ``boolean` `flag = ``false``;` `        ``// Traverse the vector V``        ``for` `(``int` `i = ``0``; i < v.size(); i++) {` `            ``// If flag is false and if``            ``// v[i] is divisible by K``            ``if` `(!flag && v.get(i) % K == ``0``)``                ``v.add(v.get(i) / K);` `            ``// Otherwise, set flag as true``            ``else` `{``                ``flag = ``true``;``            ``}` `            ``// Increment the sum by v[i % N]``            ``sum = sum + v.get(i % N);``        ``}` `        ``// Return the resultant sum``        ``return` `sum;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main (String[] args) {``        ``int` `arr[] = { ``4``, ``6``, ``8``, ``2` `};``        ``int` `K = ``2``;``        ``int` `N = arr.length;``        ``System.out.println(sum(arr, N, K));``    ``}``}` `// This code is contributed by Dharanendra L V.`

## Python3

 `# Python  program for the above approach` `# Function to calculate sum of array``# elements after adding arr[i] / K``# to the end of the array if arr[i]``# is divisible by K``def` `Sum``(arr, N, K):``    ` `    ``# Stores the sum of the array``    ``sum` `=` `0``    ` `    ``# Stores the array elements``    ``v ``=` `[]``    ` `    ``# Traverse the array``    ``for` `i ``in` `range``(N):``        ``v.append(arr[i])``    ` `    ``# Stores if the operation``    ``# should be formed or not``    ``flag ``=` `False``    ` `    ``i ``=` `0``    ``lenn ``=` `len``(v)``    ` `    ``# Traverse the vector V``    ``while``(i < lenn):``        ` `        ``# If flag is false and if``        ``# v[i] is divisible by K``        ``if``( flag ``=``=` `False` `and` `(v[i] ``%` `K ``=``=` `0``)):``            ``v.append(v[i]``/``/``K)``        ` `        ``# Otherwise, set flag as true``        ``else``:``            ``flag ``=` `True``        ` `        ``# Increment the sum by v[i % N]``        ``sum` `+``=` `v[i ``%` `N]``        ``i ``+``=` `1``        ``lenn ``=` `len``(v)``    ` `    ``# Return the resultant sum``    ``return` `sum` `# Driver Code``arr ``=` `[ ``4``, ``6``, ``8``, ``2``]``K ``=` `2``N ``=` `len``(arr)``print``(``Sum``(arr, N, K))``    ` `# This code is contributed by avanitrachhadiya2155`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `// Function to calculate sum of array``// elements after adding arr[i] / K``// to the end of the array if arr[i]``// is divisible by K``static` `int` `sum(``int` `[]arr, ``int` `N, ``int` `K)``{``    ` `    ``// Stores the sum of the array``    ``int` `sum = 0;` `    ``// Stores the array elements``    ``List<``int``> v = ``new` `List<``int``>();` `    ``// Traverse the array``    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ``v.Add(arr[i]);``    ``}` `    ``// Stores if the operation``    ``// should be formed or not``    ``bool` `flag = ``false``;` `    ``// Traverse the vector V``    ``for``(``int` `i = 0; i < v.Count; i++)``    ``{``        ` `        ``// If flag is false and if``        ``// v[i] is divisible by K``        ``if` `(!flag && v[i] % K == 0)``            ``v.Add(v[i] / K);` `        ``// Otherwise, set flag as true``        ``else``        ``{``            ``flag = ``true``;``        ``}` `        ``// Increment the sum by v[i % N]``        ``sum = sum + v[i % N];``    ``}` `    ``// Return the resultant sum``    ``return` `sum;``}` `// Driver Code``static` `void` `Main()``{``    ``int``[] arr = { 4, 6, 8, 2 };``    ``int` `K = 2;``    ``int` `N = arr.Length;``    ` `    ``Console.WriteLine(sum(arr, N, K));``}``}` `// This code is contributed by SoumikMondal`

## Javascript

 ``
Output:
`44`

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up