## Question

Given an integer array `nums`

, return *an array* `answer`

*such that* `answer[i]`

*is equal to the product of all the elements of* `nums`

*except* `nums[i]`

.

The product of any prefix or suffix of `nums`

is **guaranteed** to fit in a **32-bit** integer.

You must write an algorithm that runs in `O(n)`

time and without using the division operation.

**Example 1:**

```
Input: nums = [1,2,3,4]
Output: [24,12,8,6]
```

**Example 2:**

```
Input: nums = [-1,1,0,-3,3]
Output: [0,0,9,0,0]
```

**Constraints:**

`2 <= nums.length <= 105`

`-30 <= nums[i] <= 30`

- The product of any prefix or suffix of
`nums`

is**guaranteed**to fit in a**32-bit**integer.

## Algorithm

- Typical array questions, use prefix product to solve it.
- Handle the result segment by segment
- Multiply numbers from left and move forward one digit, so res[i] = res[i-1] * nums[i-1], current index is not included;
- Multiply numbers from right and move backwards one digit,
`right`

here is the product of right part (except the current element itself)

## Code

class Solution { public int[] productExceptSelf(int[] nums) { int[] res = new int[nums.length]; res[0] = 1; for (int i = 1; i < nums.length; i++) { res[i] = res[i - 1] * nums[i - 1]; } int right = 1; for (int i = nums.length - 1; i >= 0; i--) { res[i] *= right; right *= nums[i]; } return res; } }