Table of Contents

# Product of Array Except Self – LeetCode Solution Java , Python 3, Python 2 , C , C++, Best and Optimal Solutions , All you need.

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 <= 10`

^{5}`-30 <= nums[i] <= 30`

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

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

# C++ Product of Array Except Self LeetCode Solution

```
``````
class Solution {
public:
vector<int> productExceptSelf(vector<int>& nums) {
int prod = 1, zeroCnt = count(begin(nums), end(nums), 0);
if(zeroCnt > 1) return vector<int>(size(nums)); // Case-1
for(auto c : nums)
if(c) prod *= c; // calculate product of all elements except 0
for(auto& c : nums)
if(zeroCnt) c = c ? 0 : prod; // Case-2
else c = prod / c; // Case-3
return nums;
}
};
```

# Java Product of Array Except Self LeetCode Solution

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

}

# Python 3 Product of Array Except Self LeetCode Solution

```
``````
class Solution:
def productExceptSelf(self, nums):
prod, zero_cnt = reduce(lambda a, b: a*(b if b else 1), nums, 1), nums.count(0)
if zero_cnt > 1: return [0]*len(nums)
for i, c in enumerate(nums):
if zero_cnt: nums[i] = 0 if c else prod
else: nums[i] = prod // c
return nums
```

Array-1180

String-562

Hash Table-412

Dynamic Programming-390

Math-368

Sorting-264

Greedy-257

Depth-First Search-256

Database-215

Breadth-First Search-200

Tree-195

Binary Search-191

Matrix-176

Binary Tree-160

Two Pointers-151

Bit Manipulation-140

Stack-133

Heap (Priority Queue)-117

Design-116

Graph-108

Simulation-103

Prefix Sum-96

Backtracking-92

Counting-86

Sliding Window-73

Linked List-69

Union Find-66

Ordered Set-48

Monotonic Stack-47

Recursion-43

Trie-41

Binary Search Tree-40

Divide and Conquer-40

Enumeration-39

Bitmask-37

Queue-33

Memoization-32

Topological Sort-31

Geometry-30

Segment Tree-27

Game Theory-24

Hash Function-24

Binary Indexed Tree-21

Interactive-18

Data Stream-17

String Matching-17

Rolling Hash-17

Shortest Path-16

Number Theory-16

Combinatorics-15

Randomized-12

Monotonic Queue-9

Iterator-9

Merge Sort-9

Concurrency-9

Doubly-Linked List-8

Brainteaser-8

Probability and Statistics-7

Quickselect-7

Bucket Sort-6

Suffix Array-6

Minimum Spanning Tree-5

Counting Sort-5

Shell-4

Line Sweep-4

Reservoir Sampling-4

Eulerian Circuit-3

Radix Sort-3

Strongly Connected Componen-t2

Rejection Sampling-2

Biconnected Component-1

## Leave a comment below