Related Articles
Right most non-zero digit in multiplication of array elements
• Difficulty Level : Medium
• Last Updated : 23 Aug, 2019

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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

1. 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.
2. Now what we can do is divide each array element into its shortest divisible form by 5 and increase count of such occurrences.
3. 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.
4. Set the multiplier value as either 1 or 5 in case count of 5 is not 0 after above two loops.
5. 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 ``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);`` ` `    ``cout << rightmostNonZero(a, n);`` ` `    ``return` `0;``}`

## 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`

## 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`

## 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`
Output:
```6
```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up