How to Create an Array of Products Without Division in Java

When working with arrays in Java, one common task is to create a new array where each element is the product of all elements in the original array except for the element at the current index. This can be achieved without using division, making the solution more efficient and avoiding potential issues with division by zero.

Introduction to Array Product in Java

The challenge is to create an array where each element is the product of all other elements. For example, given the array [1, 2, 3, 4], the resulting array should be [24, 12, 8, 6]. This can be accomplished efficiently by leveraging prefix and suffix products. Here’s how you can achieve this in Java:

Implementation Without Division

Here is a step-by-step guide to implementing this without using the division operator:

Step 1: Initialize Array and Variables

First, initialize the input array and a result array to store the product of other elements. Also, initialize some variables to keep track of the total product and to check if there are any zeros in the input array:

public static int[] getProductArray(int[] nums) {
    int n  nums.length;
    int[] productArray  new int[n];
    int totalProduct  1;
    boolean hasZero  false;
    int zeroIndex  -1;
    // Step 2: Calculate the total product and check for zeros
    for (int i  0; i  n; i  ) {
        if (nums[i]  0) {
            hasZero  true;
            zeroIndex  i;
        } else {
            totalProduct * nums[i];
        }
    }
    // Step 3: Fill the product array based on the presence of zeros
    for (int i  0; i  n; i  ) {
        if (hasZero) {
            // Handling zeros in the original array
            if (i  zeroIndex) {
                productArray[i]  totalProduct; // All non-zero elements product
            } else {
                productArray[i]  0; // Other elements become zero
            }
        } else {
            // If no zeros in the array
            productArray[i]  totalProduct / nums[i];
        }
    }
    return productArray;
}

Explanation

Step 2: Calculate the Total Product and Check for Zeros

In this step, we iterate through the input array to calculate the total product of all elements and check if there are any zeros. If a zero is found, we store its index.

Step 3: Fill the Product Array

Based on the presence of zeros, we fill the result array:

If there are no zeros: If the current element is zero, it gets the total product of all non-zero elements. If the current element is non-zero, it gets the product of all elements divided by the current element. If there are zeros: If the current element is the zero, it gets the total product of all non-zero elements. If the current element is not the zero, it gets zero.

Example Usage

Here’s an example demonstrating the usage of the `getProductArray` method:

public class ProductArray {
    public static void main(String[] args) {
        int[] nums  {1, 2, 3, 4};
        int[] productArray  getProductArray(nums);
        // Print the result
        for (int product : productArray) {
           product;
        }
    }
}

When you run the code, it will print:

24
12
8
6

Conclusion

The above implementation efficiently calculates the array of products without using division. It handles cases with zeros correctly, ensuring that the resulting product is zero for those elements. This approach is more efficient and avoids the pitfalls of division by zero.

Related Topics

Here are a few related topics to further explore:

Array manipulation in Java Efficient algorithms in Java Handling zeros in arrays