Sum of array elements after reversing each element

0 0 6 minutes read

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:

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:

Time Complexity: O(N*log₁₀M), where N denotes the length of the array and M denotes maximum array element.
Auxiliary Space: O(1)

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 zambiatek!