#1822

Easy

LeetCode Problem Workspace

Sign of the Product of an Array

Determine the sign of a product from an integer array using a single pass without computing the full product.

Problem Statement

You are given an integer array nums. Calculate the product of all its elements and determine the overall sign without computing the exact product, which may cause overflow.

Implement a function signFunc(x) that returns 1 if x is positive, -1 if x is negative, and 0 if x is zero. Return signFunc(product) for the product of all elements in nums.

Examples

Example 1

Input: nums = [-1,-2,-3,-4,3,2,1]

Output: 1

The product of all values in the array is 144, and signFunc(144) = 1

Example 2

Input: nums = [1,5,0,2,-3]

Output: 0

The product of all values in the array is 0, and signFunc(0) = 0

Example 3

Input: nums = [-1,1,-1,1,-1]

Output: -1

The product of all values in the array is -1, and signFunc(-1) = -1

Constraints

1 <= nums.length <= 1000
-100 <= nums[i] <= 100

Solution Approach

Count negatives and check zeros

Iterate through nums, increment a counter for each negative number and return 0 immediately if a zero is found. After the loop, the sign is -1 if the negative count is odd, otherwise 1.

Avoid full product multiplication

Instead of multiplying all numbers which may overflow, focus on counting negatives and detecting zeros. This approach leverages the Array plus Math pattern and ensures safe computation.

Single pass, constant space

Use a single traversal of nums and a simple integer counter. This achieves O(n) time and O(1) space, directly reflecting the pattern of evaluating array sign without extra storage or multiplications.

Complexity Analysis

Metric	Value
Time	O(n)
Space	O(1)

Time complexity is O(n) since every element is examined once. Space complexity is O(1) because only a counter and a loop variable are used, avoiding full product computation.

What Interviewers Usually Probe

Will you multiply all numbers directly or track signs?
How do you handle zeros in the array efficiently?
Can you solve this with a single pass and constant space?

Common Pitfalls or Variants

Common pitfalls

Multiplying all numbers can overflow and is unnecessary for determining the sign.
Forgetting to return 0 immediately when a zero exists in nums.
Incorrectly counting negative numbers or mishandling even/odd counts.

Follow-up variants

Compute sign for floating-point arrays with rounding considerations.
Find the sign of the product for a subarray defined by given indices.
Return an array of signs for cumulative products from the start to each index.

FAQ

What is the best way to determine the sign of the product of an array?

Track the number of negative elements and check for zeros. Return 0 for zero presence, -1 if negatives count is odd, 1 otherwise.

Can I multiply all elements to find the product sign?

Multiplying may cause overflow. Counting negatives and detecting zeros is safer and aligns with the problem's pattern.

How does the Array plus Math pattern apply here?

You use array traversal to count negatives and zeros, then apply simple math logic to determine the final sign.

What should I do if the array contains zeros?

Immediately return 0, since any product including zero will be zero, simplifying the calculation.

Are there efficient ways to handle large arrays?

Yes, a single pass with a negative counter and zero check handles arrays up to 1000 elements in O(n) time and O(1) space.

terminal

Solution

Solution 1: Direct Traversal

The problem requires us to return the sign of the product of the array elements, i.e., return $1$ for positive numbers, $-1$ for negative numbers, and $0$ if it equals $0$.

1

2

3

4

5

6

7

8

9

class Solution:
    def arraySign(self, nums: List[int]) -> int:
        ans = 1
        for v in nums:
            if v == 0:
                return 0
            if v < 0:
                ans *= -1
        return ans

Continue Practicing

#1823 find the winner of the circular game #1819 number of different subsequences gcds #1828 queries on number of points inside a circle