Sum of array elements after reversing each element

09 Apr, 2021
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 0s 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.For each reverse number in the above step, add that value to the resultant sum.
Initialize a variable, say sum, to store the required sum.
Initialize variable count as 0 and f as false to store count of ending 0s 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 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.
For each reverse number in the above step, add that value to the resultant sum.
Below is the implementation of the above approach:
C++
Java
Python3
C#
Javascript
// 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 Codeint 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 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 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 Codeif __name__ == "__main__":     # Given arr[]    arr = [ 7, 234, 58100 ]     n = len(arr)     # Function call    totalSum(arr, n) # This code is contributed by akhilsaini
// C# program for the above approachusing 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 Codestatic public void Main(){     // Given arr[]    int[] arr = { 7, 234, 58100 };     // Function call    totalSum(arr);}} // This code is contributed by akhilsaini
<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>
18939
 
Time Complexity: O(N*log10M), where N denotes the length of the array and M denotes maximum array element. Auxiliary Space: O(1) 
akhilsaini
mayanktyagi1709
array-rearrange
number-digits
Reverse
Arrays
Mathematical
School Programming
Arrays
Mathematical
Reverse
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Maximum and minimum of an array using minimum number of comparisons
Top 50 Array Coding Problems for Interviews
Multidimensional Arrays in Java
Stack Data Structure (Introduction and Program)
Linear Search
Program for Fibonacci numbers
Set in C++ Standard Template Library (STL)
Write a program to print all permutations of a given string
C++ Data Types
Merge two sorted arrays