Dada una array arr[] que consta de N enteros positivos, la tarea es encontrar la suma de todos los elementos de la array después de invertir los dígitos de cada elemento de la array .
Ejemplos:
Entrada: arr[] = {7, 234, 58100}
Salida: 18939
Explicación:
Array modificada después de invertir cada elemento de la array = {7, 432, 18500}.
Por lo tanto, la suma de la array modificada = 7 + 432 + 18500 = 18939.Entrada: arr[] = {0, 100, 220}
Salida: 320
Explicación:
array modificada después de invertir cada elemento de la array = {0, 100, 220}.
Por lo tanto, la suma de la array modificada = 0 + 100 + 220 = 320.
Enfoque: la idea es invertir cada número de la array dada según las condiciones dadas y encontrar la suma de todos los elementos de la array formados después de la inversión. A continuación los pasos para resolver el problema:
- Inicialice una variable, digamos sum , para almacenar la suma requerida.
- Inicialice la variable count como 0 y f como false para almacenar el recuento de los 0 finales de arr[i] y marque para evitar todos los 0 que no terminen .
- Inicialice rev como 0 para almacenar la inversión de cada elemento de la array.
- Recorra la array dada y para cada elemento de la array realice la siguiente operación:
- Incremente la cuenta y divida arr[i] por 10 hasta que se atraviesen todos los ceros al final.
- Restablezca f con verdadero, lo que significa que se han considerado todos los dígitos que terminan en 0.
- Ahora, invierta arr[i] actualizando rev = rev*10 + arr[i] % 10 y arr[i] = arr[i]/10 .
- Después de recorrer cada dígito de arr[i], actualice rev = rev * Math.pow(10, count) para agregar todos los 0 finales al final del número invertido.
- Para cada número inverso en el paso anterior, agregue ese valor a la suma resultante .
A continuación se muestra la implementación del enfoque anterior:
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>
Producción:
18939
Complejidad de tiempo: O(N*log 10 M), donde N denota la longitud de la array y M denota el elemento máximo de la array.
Espacio Auxiliar: O(1)