Check If It Is a Good Array - Practice Coding Problems

Check If It Is a Good Array - Problem

Check If It Is a Good Array

Given an array nums of positive integers, your task is to determine if it's a "good" array. An array is considered good if you can select any subset of its elements, multiply each selected element by any integer (positive, negative, or zero), and make the sum equal to exactly 1.

This is essentially asking: Can we find integers a₁, a₂, ..., aₙ such that a₁×nums[0] + a₂×nums[1] + ... + aₙ×nums[n-1] = 1?

🎯 Goal: Return true if the array is good, false otherwise.

Mathematical Insight: This problem is rooted in number theory - specifically Bézout's identity, which states that a linear combination of integers can produce 1 if and only if their greatest common divisor (GCD) is 1.

Input & Output

example_1.py — Basic Good Array

$ Input: nums = [12, 30, 15]

› Output: false

💡 Note: GCD(12, 30, 15) = 3 ≠ 1, so no linear combination can equal 1. The array is not good.

example_2.py — Simple Good Array

$ Input: nums = [6, 10, 15]

› Output: true

💡 Note: GCD(6, 10, 15) = 1, so we can find integers to make sum = 1. For example: 4×6 + (-1)×10 + (-1)×15 = 24 - 10 - 15 = -1... Actually, by Bézout's identity, a solution exists.

example_3.py — Single Element

$ Input: nums = [1]

› Output: true

💡 Note: GCD(1) = 1, and we can simply use 1×1 = 1. Single element arrays with value 1 are always good.

Visualization

Tap to expand

Understanding the Visualization

The Problem

Find integers a₁, a₂, ..., aₙ such that a₁×nums[0] + a₂×nums[1] + ... = 1

Bézout's Identity

This equation has integer solutions iff gcd(nums[0], nums[1], ...) = 1

Algorithm

Compute GCD of all array elements in linear time

Result

Return true if GCD equals 1, false otherwise

Key Takeaway

🎯 Key Insight: Instead of trying infinite combinations, use the mathematical fact that linear combinations can produce 1 if and only if the GCD of all numbers is 1. This transforms an intractable problem into a simple O(n) algorithm!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array, GCD computation is effectively constant for practical numbers

✓ Linear Growth

Space Complexity

O(1)

Only storing the running GCD value

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10³
1 ≤ nums[i] ≤ 10⁹
All integers in nums are positive

Asked in

G Google 25 ⊞ Microsoft 18 a Amazon 12 f Meta 8

The optimal solution uses Bézout's identity from number theory: an array is good if and only if the GCD of all elements equals 1. This reduces the problem from trying infinite combinations to a simple O(n) GCD computation.

Common Approaches

Approach	Time	Space	Notes
✓ GCD-Based Solution (Optimal)	O(n)	O(1)	Use Bézout's identity: array is good iff GCD of all elements is 1
Brute Force (Try All Combinations)	O(∞)	O(2^n)	Generate all possible subsets and test multiplier combinations

GCD-Based Solution (Optimal) — Algorithm Steps

Initialize GCD with the first element
Iterate through remaining elements
Update GCD using the Euclidean algorithm
Return true if final GCD equals 1

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with first element as initial GCD

Iterate

Compute GCD with each subsequent element

Check Result

If final GCD = 1, array is good

Code -

solution.c — C

#include <stdio.h>
#include <stdbool.h>

int gcd(int a, int b) {
    while (b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

bool isGoodArray(int* nums, int numsSize) {
    if (numsSize == 0) return false;
    
    int currentGcd = nums[0];
    
    for (int i = 1; i < numsSize; i++) {
        currentGcd = gcd(currentGcd, nums[i]);
        if (currentGcd == 1) {
            return true;
        }
    }
    
    return currentGcd == 1;
}

int main() {
    int n;
    scanf("%d", &n);
    int nums[1000];
    for (int i = 0; i < n; i++) {
        scanf("%d", &nums[i]);
    }
    
    printf("%s\n", isGoodArray(nums, n) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array, GCD computation is effectively constant for practical numbers

✓ Linear Growth

Space Complexity

O(1)

Only storing the running GCD value

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10³
1 ≤ nums[i] ≤ 10⁹
All integers in nums are positive

31.4K Views

Medium Frequency

~15 min Avg. Time

742 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

GCD-Based Solution (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler