Sum of array elements after reversing each element

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: 18939

Explanation:

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: 320

Explanation:

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.

Below is the implementation of the above approach:

// 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); 

    } 

} 

Output:

18939

Time Complexity: O(N*log10M), where N denotes the length of the array and M denotes maximum array element.

Auxiliary Space: O(1)