Question: I have an `int[]` array with x values (x can be defined by the user), the values are random ints between 1 and 9. Now I want to create another Array with the same amount of values, and each value of the new Array is the product of all values from the other Array, except the same index.

So for example: 

* Array1: `{4,3,5,7}`
* Array2: `{3*5*7, 4*5*7, 4*3*7, 4*3*5} = {105, 140, 84, 60}`

Here's what I have:

```
public static int[] multiplyArrayValues (int [] values) {

    int array[] = new int[values.length];

    for (int y = 0; y < array.length; y++) {
        array[y] = 1;
    }

    /*for (int i = 0; i < array.length; i++) {      // wrong                        
        for (int z = 0; z < x; z++) {                           
            if (z != i) {                                                   
                array[i] = array[i] * values[z];                                        
            }               
        }           
    }*/

    return array;
}  

```

The difficulty is, I have to avoid for-loops in for-loops for performance. Which is why that one block is commented-out. Dividing is not allowed.

Answer: 
First multiply all the elements from the array. And then loop over all elements and divide the previously computed multiplication with current item.
```
import java.util.Arrays;

public class Main {

    static int[] multiplyArrayValues(int[] values) {
        int product = 1;
        for(int i = 0; i < values.length; i++){
            product *= values[i];
        }
        int[] result = new int[values.length];
        for (int i = 0; i < result.length; i++) {
            result[i] = product / values[i];
        }
        return result;
    }

    static void testMultiplyArrayValues(int[] values)
    {
        System.out.println(Arrays.toString(values) + " => " + Arrays.toString(multiplyArrayValues(values)));
    }

    public static void main(String[] args) {
        testMultiplyArrayValues(new int[] {1,1,2,3});
        testMultiplyArrayValues(new int[] {4,3,5,7});
        testMultiplyArrayValues(new int[] {9,9,9,9});
        testMultiplyArrayValues(new int[] {1,1,1,1});
        testMultiplyArrayValues(new int[] {1,2,3,4});
    }

}

```

Output:

```
[1, 1, 2, 3] => [6, 6, 3, 2]
[4, 3, 5, 7] => [105, 140, 84, 60]
[9, 9, 9, 9] => [729, 729, 729, 729]
[1, 1, 1, 1] => [1, 1, 1, 1]
[1, 2, 3, 4] => [24, 12, 8, 6]

```

If the range of possible values changes you might want to change the data types of `product` and the return value of `multiplyArrayValues`.
Also there is no check for the values being negative or invalid. Zero will lead to a crash.