Given an array **arr[]** consisting of **N** positive integers, the task is to find the sum of all array elements after reversing digits of every array element.

**Examples:**

Input:arr[] = {7, 234, 58100}Output:18939Explanation:

Modified array after reversing each array elements = {7, 432, 18500}.

Therefore, the sum of the modified array = 7 + 432 + 18500 = 18939.

Input:arr[] = {0, 100, 220}Output:320Explanation:

Modified array after reversing each array elements = {0, 100, 220}.

Therefore, the sum of the modified array = 0 + 100 + 220 = 320.

**Approach:** The idea is to reverse each number of the given array as per the given conditions and find sum of all array elements formed after reversing. Below steps to solve the problem:

- Initialize a variable, say
**sum**, to store the required sum. - Initialize variable
**count**as**0**and**f**as**false**to store count of ending**0**s of**arr[i]**and flag to avoid all non-ending**0**. - Initialize
**rev**as**0**to store reversal of each array element. - Traverse the given array and for each array element do the following operation:
- Increment
**count**and divide**arr[i]**by 10 until all the zeros at the end are traversed. - Reset
**f**with true that means all ending 0 digits have been considered. - Now, reverse
**arr[i]**by updating**rev = rev*10 + arr[i] % 10**and**arr[i] = arr[i]/10**. - After traversing each digit of arr[i], update
**rev = rev * Math.pow(10, count)**to add all ending 0’s to the end of reversed number.

- Increment
- For each reverse number in the above step, add that value to the resultant
**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 elements` `// after reversing each element in arr[]` `void` `totalSum(` `int` `arr[], ` `int` `n)` `{` ` ` ` ` `// Stores the final sum` ` ` `int` `sum = 0;` ` ` `// Traverse the given array` ` ` `for` `(` `int` `i = 0; i < n; i++)` ` ` `{` ` ` ` ` `// Stores count of ending 0s` ` ` `int` `count = 0;` ` ` `int` `rev = 0, num = arr[i];` ` ` `// Flag to avoid count of 0s` ` ` `// that doesn't ends with 0s` ` ` `bool` `f = ` `false` `;` ` ` `while` `(num > 0)` ` ` `{` ` ` ` ` `// Count of ending 0s` ` ` `while` `(num > 0 && !f &&` ` ` `num % 10 == 0)` ` ` `{` ` ` `count++;` ` ` `num = num / 10;` ` ` `}` ` ` `// Update flag with true` ` ` `f = ` `true` `;` ` ` `// Reversing the num` ` ` `if` `(num > 0)` ` ` `{` ` ` `rev = rev * 10 +` ` ` `num % 10;` ` ` `num = num / 10;` ` ` `}` ` ` `}` ` ` `// Add all ending 0s to` ` ` `// end of rev` ` ` `if` `(count > 0)` ` ` `rev = rev * ` `pow` `(10, count);` ` ` `// Update sum` ` ` `sum = sum + rev;` ` ` `}` ` ` `// Print total sum` ` ` `cout << sum;` `}` `// Driver Code` `int` `main()` `{` ` ` ` ` `// Given arr[]` ` ` `int` `arr[] = { 7, 234, 58100 };` ` ` `int` `n = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]);` ` ` ` ` `// Function call` ` ` `totalSum(arr, n);` ` ` ` ` `return` `0;` `}` `// This code is contributed by akhilsaini` |

## Java

`// Java program for the above approach` `import` `java.util.*;` `class` `GFG {` ` ` `// Function to find the sum of elements` ` ` `// after reversing each element in arr[]` ` ` `static` `void` `totalSum(` `int` `[] arr)` ` ` `{` ` ` `// Stores the final sum` ` ` `int` `sum = ` `0` `;` ` ` `// Traverse the given array` ` ` `for` `(` `int` `i = ` `0` `;` ` ` `i < arr.length; i++) {` ` ` `// Stores count of ending 0s` ` ` `int` `count = ` `0` `;` ` ` `int` `rev = ` `0` `, num = arr[i];` ` ` `// Flag to avoid count of 0s` ` ` `// that doesn't ends with 0s` ` ` `boolean` `f = ` `false` `;` ` ` `while` `(num > ` `0` `) {` ` ` `// Count of ending 0s` ` ` `while` `(num > ` `0` `&& !f` ` ` `&& num % ` `10` `== ` `0` `) {` ` ` `count++;` ` ` `num = num / ` `10` `;` ` ` `}` ` ` `// Update flag with true` ` ` `f = ` `true` `;` ` ` `// Reversing the num` ` ` `if` `(num > ` `0` `) {` ` ` `rev = rev * ` `10` ` ` `+ num % ` `10` `;` ` ` `num = num / ` `10` `;` ` ` `}` ` ` `}` ` ` `// Add all ending 0s to` ` ` `// end of rev` ` ` `if` `(count > ` `0` `)` ` ` `rev = rev` ` ` `* (` `int` `)Math.pow(` `10` `,` ` ` `count);` ` ` `// Update sum` ` ` `sum = sum + rev;` ` ` `}` ` ` `// Print total sum` ` ` `System.out.print(sum);` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` ` ` `main(String[] args)` ` ` `{` ` ` `// Given arr[]` ` ` `int` `[] arr = { ` `7` `, ` `234` `, ` `58100` `};` ` ` `// Function Call` ` ` `totalSum(arr);` ` ` `}` `}` |

## Python3

`# Python3 program for the above approach` `# Function to find the sum of elements` `# after reversing each element in arr[]` `def` `totalSum(arr, n):` ` ` ` ` `# Stores the final sum` ` ` `sums ` `=` `0` ` ` `# Traverse the given array` ` ` `for` `i ` `in` `range` `(` `0` `, n):` ` ` ` ` `# Stores count of ending 0s` ` ` `count ` `=` `0` ` ` `rev ` `=` `0` ` ` `num ` `=` `arr[i]` ` ` `# Flag to avoid count of 0s` ` ` `# that doesn't ends with 0s` ` ` `f ` `=` `False` ` ` `while` `num > ` `0` `:` ` ` `# Count of ending 0s` ` ` `while` `(num > ` `0` `and` `f ` `=` `=` `False` `and` ` ` `num ` `%` `10` `=` `=` `0` `):` ` ` `count ` `=` `count ` `+` `1` ` ` `num ` `=` `num ` `/` `/` `10` ` ` `# Update flag with true` ` ` `f ` `=` `True` ` ` `# Reversing the num` ` ` `if` `num > ` `0` `:` ` ` `rev ` `=` `rev ` `*` `10` `+` `num ` `%` `10` ` ` `num ` `=` `num ` `/` `/` `10` ` ` `# Add all ending 0s to` ` ` `# end of rev` ` ` `if` `(count > ` `0` `):` ` ` `rev ` `=` `rev ` `*` `pow` `(` `10` `, count)` ` ` `# Update sum` ` ` `sums ` `=` `sums ` `+` `rev` ` ` `# Print total sum` ` ` `print` `(sums)` `# Driver Code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `# Given arr[]` ` ` `arr ` `=` `[ ` `7` `, ` `234` `, ` `58100` `]` ` ` `n ` `=` `len` `(arr)` ` ` `# Function call` ` ` `totalSum(arr, n)` `# This code is contributed by akhilsaini` |

## C#

`// C# program for the above approach` `using` `System;` `class` `GFG{` `// Function to find the sum of elements` `// after reversing each element in arr[]` `static` `void` `totalSum(` `int` `[] arr)` `{` ` ` ` ` `// Stores the final sum` ` ` `int` `sum = 0;` ` ` `// Traverse the given array` ` ` `for` `(` `int` `i = 0; i < arr.Length; i++)` ` ` `{` ` ` ` ` `// Stores count of ending 0s` ` ` `int` `count = 0;` ` ` `int` `rev = 0, num = arr[i];` ` ` `// Flag to avoid count of 0s` ` ` `// that doesn't ends with 0s` ` ` `bool` `f = ` `false` `;` ` ` `while` `(num > 0)` ` ` `{` ` ` ` ` `// Count of ending 0s` ` ` `while` `(num > 0 && !f &&` ` ` `num % 10 == 0)` ` ` `{` ` ` `count++;` ` ` `num = num / 10;` ` ` `}` ` ` `// Update flag with true` ` ` `f = ` `true` `;` ` ` `// Reversing the num` ` ` `if` `(num > 0)` ` ` `{` ` ` `rev = rev * 10 +` ` ` `num % 10;` ` ` `num = num / 10;` ` ` `}` ` ` `}` ` ` `// Add all ending 0s to` ` ` `// end of rev` ` ` `if` `(count > 0)` ` ` `rev = rev * (` `int` `)Math.Pow(10, count);` ` ` `// Update sum` ` ` `sum = sum + rev;` ` ` `}` ` ` `// Print total sum` ` ` `Console.Write(sum);` `}` `// Driver Code` `static` `public` `void` `Main()` `{` ` ` `// Given arr[]` ` ` `int` `[] arr = { 7, 234, 58100 };` ` ` `// Function call` ` ` `totalSum(arr);` `}` `}` `// This code is contributed by akhilsaini` |

## Javascript

`<script>` `// Javascript program for the above approach` `// Function to find the sum of elements` `// after reversing each element in arr[]` `function` `totalSum(arr, n)` `{` ` ` ` ` `// Stores the final sum` ` ` `let sum = 0;` ` ` `// Traverse the given array` ` ` `for` `(let i = 0; i < n; i++)` ` ` `{` ` ` ` ` `// Stores count of ending 0s` ` ` `let count = 0;` ` ` `let rev = 0, num = arr[i];` ` ` `// Flag to avoid count of 0s` ` ` `// that doesn't ends with 0s` ` ` `let f = ` `false` `;` ` ` `while` `(num > 0)` ` ` `{` ` ` ` ` `// Count of ending 0s` ` ` `while` `(num > 0 && !f &&` ` ` `num % 10 == 0)` ` ` `{` ` ` `count++;` ` ` `num = Math.floor(num / 10);` ` ` `}` ` ` `// Update flag with true` ` ` `f = ` `true` `;` ` ` `// Reversing the num` ` ` `if` `(num > 0)` ` ` `{` ` ` `rev = rev * 10 +` ` ` `num % 10;` ` ` `num = Math.floor(num / 10);` ` ` `}` ` ` `}` ` ` `// Add all ending 0s to` ` ` `// end of rev` ` ` `if` `(count > 0)` ` ` `rev = rev * Math.pow(10, count);` ` ` `// Update sum` ` ` `sum = sum + rev;` ` ` `}` ` ` `// Print total sum` ` ` `document.write(sum);` `}` `// Driver Code` ` ` `// Given arr[]` ` ` `let arr = [ 7, 234, 58100 ];` ` ` `let n = arr.length;` ` ` `// Function call` ` ` `totalSum(arr, n);` `// This code is contributed by Mayank Tyagi` `</script>` |

**Output:**

18939

**Time Complexity:** O(N*log_{10}M), where N denotes the length of the array and M denotes maximum array element. **Auxiliary Space:** O(1)

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 industry experts, please refer **Geeks Classes Live**