Sum of array elements after reversing each element
Last Updated :
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: 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 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 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# 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
<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>
Time Complexity: O(N*log10M), where N denotes the length of the array and M denotes maximum array element.
Auxiliary Space: O(1)
Similar Reads
Sum of odd Array elements after each update query Given an integer array Arr[] of length N and an array Queries[] of length Q where Queries[i] = [valuei, indexi]. For each query i, update Arr[indexi] = Arr[indexi] + valuei, then print the sum of the all the odd values of Arr[]. Examples: Input: N = 4, Arr = [1,2,3,5], Q = 4, Queries = [[1,0],[-3,1]
15+ min read
Sum of product of each element with each element after it Given an array arr[] of n integers. The task is to find the sum of product of each element with each element after it in the array. In other words, find sum of product of each arr[i] with each arr[j] such that j > i. Examples : Input : arr[] = {9, 3, 4, 2}Output : 107Explanation: Sum of product o
10 min read
Count remaining array elements after reversing binary representation of each array element Given an array arr[] consisting of N positive integers, the task is to modify every array element by reversing them binary representation and count the number of elements in the modified array that were also present in the original array. Examples: Input: arr[] = {2, 4, 5, 20, 16} Output: 2Explanati
8 min read
Replace every element of the array by sum of all other elements Given an array of size N, the task is to find the encrypted array. The encrypted array is obtained by replacing each element of the original array with the sum of the remaining array elements i.e. For every i, arr[i] = sumOfArrayElements - arr[i] Examples: Input: arr[] = {5, 1, 3, 2, 4} Output: 10 1
5 min read
Replace every element of array with sum of elements on its right side Given an array arr[], the task is to replace every element of the array with the sum of elements on its right side.Examples: Input: arr[] = {1, 2, 5, 2, 2, 5} Output: 16 14 9 7 5 0 Input: arr[] = {5, 1, 3, 2, 4} Output: 10 9 6 4 0 Naive Approach: A simple approach is to run two loops, Outer loop to
8 min read
Minimum increments or decrements required to signs of prefix sum array elements alternating Given an array arr[] of N integers, the task is to find the minimum number of increments/decrements of array elements by 1 to make the sign of prefix sum of array alternating. Examples: Input: arr[] = {1, -3, 1, 0}Output: 4Explanation:Following are the operations performed on the given array element
8 min read