# Right most non-zero digit in multiplication of array elements

Given an array **arr[]** of **N** non-negative integers. The task is to find the right most non zero digit in the product of array elements.

**Examples:**

Input:arr[] = {3, 5, 6, 90909009}

Output:7

Input:arr[] = {7, 42, 11, 64}

Output:6

Result of multiplication is 206976

So the rightmost digit is 6

**Approach:**

- The question is too much simple if you know basic maths. It is given that you have to find the rightmost positive digit. Now a digit is made multiple of 10, if there are 2 and 5. They produce a number with last digit 0.
- Now what we can do is divide each array element into its shortest divisible form by 5 and increase count of such occurrences.
- Now divide each array element into its shortest divisible form by 2 and decrease count of such occurrences. This way we are not considering the multiplication of 2 and a 5 in our multiplication.
- Set the multiplier value as either 1 or 5 in case count of 5 is not 0 after above two loops.
- Multiply each array variable now and store just last digit by taking remainder by 10

Below is the implementation of the above approach:

## C++

`// C++ implementation of the approach ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Function to return the rightmost non-zero ` `// digit in the multiplication ` `// of the array elements ` `int` `rightmostNonZero(` `int` `a[], ` `int` `n) ` `{ ` ` ` `// To store the count of times 5 can ` ` ` `// divide the array elements ` ` ` `int` `c5 = 0; ` ` ` ` ` `// Divide the array elements by 5 ` ` ` `// as much as possible ` ` ` `for` `(` `int` `i = 0; i < n; i++) { ` ` ` `while` `(a[i] > 0 && a[i] % 5 == 0) { ` ` ` `a[i] /= 5; ` ` ` `// increase count of 5 ` ` ` `c5++; ` ` ` `} ` ` ` `} ` ` ` ` ` `// Divide the array elements by ` ` ` `// 2 as much as possible ` ` ` `for` `(` `int` `i = 0; i < n; i++) { ` ` ` `while` `(c5 && a[i] > 0 && !(a[i] & 1)) { ` ` ` `a[i] >>= 1; ` ` ` ` ` `// Decrease count of 5, because a '2' and ` ` ` `// a '5' makes a number with last digit '0' ` ` ` `c5--; ` ` ` `} ` ` ` `} ` ` ` `long` `long` `ans = 1; ` ` ` `for` `(` `int` `i = 0; i < n; i++) { ` ` ` `ans = (ans * a[i] % 10) % 10; ` ` ` `} ` ` ` ` ` `// If c5 is more than the multiplier ` ` ` `// should be taken as 5 ` ` ` `if` `(c5) ` ` ` `ans = (ans * 5) % 10; ` ` ` ` ` `if` `(ans) ` ` ` `return` `ans; ` ` ` ` ` `return` `-1; ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` `int` `a[] = { 7, 42, 11, 64 }; ` ` ` `int` `n = ` `sizeof` `(a) / ` `sizeof` `(a[0]); ` ` ` ` ` `cout << rightmostNonZero(a, n); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java implementation of the approach ` `import` `java.util.*; ` ` ` `class` `GFG ` `{ ` ` ` `// Function to return the rightmost non-zero ` `// digit in the multiplication ` `// of the array elements ` `static` `int` `rightmostNonZero(` `int` `a[], ` `int` `n) ` `{ ` ` ` `// To store the count of times 5 can ` ` ` `// divide the array elements ` ` ` `int` `c5 = ` `0` `; ` ` ` ` ` `// Divide the array elements by 5 ` ` ` `// as much as possible ` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++) ` ` ` `{ ` ` ` `while` `(a[i] > ` `0` `&& a[i] % ` `5` `== ` `0` `) ` ` ` `{ ` ` ` `a[i] /= ` `5` `; ` ` ` ` ` `// increase count of 5 ` ` ` `c5++; ` ` ` `} ` ` ` `} ` ` ` ` ` `// Divide the array elements by ` ` ` `// 2 as much as possible ` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++) ` ` ` `{ ` ` ` `while` `(c5 != ` `0` `&& a[i] > ` `0` `&& ` ` ` `(a[i] & ` `1` `) == ` `0` `) ` ` ` `{ ` ` ` `a[i] >>= ` `1` `; ` ` ` ` ` `// Decrease count of 5, because a '2' and ` ` ` `// a '5' makes a number with last digit '0' ` ` ` `c5--; ` ` ` `} ` ` ` `} ` ` ` ` ` `int` `ans = ` `1` `; ` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++) ` ` ` `{ ` ` ` `ans = (ans * a[i] % ` `10` `) % ` `10` `; ` ` ` `} ` ` ` ` ` `// If c5 is more than the multiplier ` ` ` `// should be taken as 5 ` ` ` `if` `(c5 != ` `0` `) ` ` ` `ans = (ans * ` `5` `) % ` `10` `; ` ` ` ` ` `if` `(ans != ` `0` `) ` ` ` `return` `ans; ` ` ` ` ` `return` `-` `1` `; ` `} ` ` ` `// Driver code ` `public` `static` `void` `main(String args[]) ` `{ ` ` ` `int` `a[] = { ` `7` `, ` `42` `, ` `11` `, ` `64` `}; ` ` ` `int` `n = a.length; ` ` ` ` ` `System.out.println(rightmostNonZero(a, n)); ` `} ` `} ` ` ` `// This code is contributed by ` `// Surendra_Gangwar ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 implementation of the approach ` ` ` `# Function to return the rightmost non-zero ` `# digit in the multiplication ` `# of the array elements ` `def` `rightmostNonZero(a, n): ` ` ` ` ` `# To store the count of times 5 can ` ` ` `# divide the array elements ` ` ` `c5 ` `=` `0` ` ` ` ` `# Divide the array elements by 5 ` ` ` `# as much as possible ` ` ` `for` `i ` `in` `range` `(n): ` ` ` `while` `(a[i] > ` `0` `and` `a[i] ` `%` `5` `=` `=` `0` `): ` ` ` `a[i] ` `/` `/` `=` `5` ` ` ` ` `# increase count of 5 ` ` ` `c5 ` `+` `=` `1` ` ` ` ` `# Divide the array elements by ` ` ` `# 2 as much as possible ` ` ` `for` `i ` `in` `range` `(n): ` ` ` `while` `(c5 ` `and` `a[i] > ` `0` `and` `(a[i] & ` `1` `) ` `=` `=` `0` `): ` ` ` `a[i] >>` `=` `1` ` ` ` ` `# Decrease count of 5, because a '2' and ` ` ` `# a '5' makes a number with last digit '0' ` ` ` `c5 ` `-` `=` `1` ` ` ` ` `ans ` `=` `1` ` ` `for` `i ` `in` `range` `(n): ` ` ` `ans ` `=` `(ans ` `*` `a[i] ` `%` `10` `) ` `%` `10` ` ` ` ` `# If c5 is more than the multiplier ` ` ` `# should be taken as 5 ` ` ` `if` `(c5): ` ` ` `ans ` `=` `(ans ` `*` `5` `) ` `%` `10` ` ` ` ` `if` `(ans): ` ` ` `return` `ans ` ` ` ` ` `return` `-` `1` ` ` `# Driver code ` `a ` `=` `[` `7` `, ` `42` `, ` `11` `, ` `64` `] ` `n ` `=` `len` `(a) ` ` ` `print` `(rightmostNonZero(a, n)) ` ` ` `# This code is contributed by Mohit Kumar ` |

*chevron_right*

*filter_none*

## C#

`// C# implementation of the approach ` `using` `System; ` ` ` `class` `GFG ` `{ ` ` ` `// Function to return the rightmost non-zero ` `// digit in the multiplication ` `// of the array elements ` `static` `int` `rightmostNonZero(` `int` `[] a, ` `int` `n) ` `{ ` ` ` ` ` `// To store the count of times 5 can ` ` ` `// divide the array elements ` ` ` `int` `c5 = 0; ` ` ` ` ` `// Divide the array elements by 5 ` ` ` `// as much as possible ` ` ` `for` `(` `int` `i = 0; i < n; i++) ` ` ` `{ ` ` ` `while` `(a[i] > 0 && a[i] % 5 == 0) ` ` ` `{ ` ` ` `a[i] /= 5; ` ` ` ` ` `// increase count of 5 ` ` ` `c5++; ` ` ` `} ` ` ` `} ` ` ` ` ` `// Divide the array elements by ` ` ` `// 2 as much as possible ` ` ` `for` `(` `int` `i = 0; i < n; i++) ` ` ` `{ ` ` ` `while` `(c5 != 0 && a[i] > 0 && ` ` ` `(a[i] & 1) == 0) ` ` ` `{ ` ` ` `a[i] >>= 1; ` ` ` ` ` `// Decrease count of 5, because a '2' and ` ` ` `// a '5' makes a number with last digit '0' ` ` ` `c5--; ` ` ` `} ` ` ` `} ` ` ` ` ` `int` `ans = 1; ` ` ` `for` `(` `int` `i = 0; i < n; i++) ` ` ` `{ ` ` ` `ans = (ans * a[i] % 10) % 10; ` ` ` `} ` ` ` ` ` `// If c5 is more than the multiplier ` ` ` `// should be taken as 5 ` ` ` `if` `(c5 != 0) ` ` ` `ans = (ans * 5) % 10; ` ` ` ` ` `if` `(ans != 0) ` ` ` `return` `ans; ` ` ` ` ` `return` `-1; ` `} ` ` ` `// Driver code ` `public` `static` `void` `Main() ` `{ ` ` ` `int` `[] a = { 7, 42, 11, 64 }; ` ` ` `int` `n = a.Length; ` ` ` ` ` `Console.WriteLine(rightmostNonZero(a, n)); ` `} ` `} ` ` ` `// This code is contributed by ` `// Code_@Mech ` |

*chevron_right*

*filter_none*

**Output:**

6

## Recommended Posts:

- Program for multiplication of array elements
- Arrange array elements such that last digit of an element is equal to first digit of the next element
- Count divisors of array multiplication
- Find the element whose multiplication with -1 makes array sum 0
- Replace every array element by multiplication of previous and next
- Find remainder of array multiplication divided by n
- Maximum subset sum such that no two elements in set have same digit in them
- Longest subsequence such that adjacent elements have at least one common digit
- Longest subarray such that adjacent elements have at least one common digit | Set - 2
- Make the list non-decreasing by changing only one digit of the elements
- Longest subarray such that adjacent elements have at least one common digit | Set 1
- Sum of elements in 1st array such that number of elements less than or equal to them in 2nd array is maximum
- First digit in product of an array of numbers
- Count pairs in an array which have at least one digit common
- Find the most frequent digit without using array/string

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.