Check If It Is a Good Array

Check If It Is a Good Array - Problem

Given an array nums of positive integers. Your task is to select some subset of nums, multiply each element by an integer and add all these numbers.

The array is said to be good if you can obtain a sum of 1 from the array by any possible subset and multiplicand.

Return True if the array is good otherwise return False.

Input & Output

Example 1 — Good Array

$ Input: nums = [12,5,7,23]

› Output: true

💡 Note: GCD(12,5,7,23) = GCD(GCD(GCD(12,5),7),23) = GCD(GCD(1,7),23) = GCD(1,23) = 1. Since GCD equals 1, we can form sum of 1 using integer combinations.

Example 2 — Not Good Array

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

› Output: true

💡 Note: GCD(29,6,10) = GCD(GCD(29,6),10) = GCD(1,10) = 1. Since GCD equals 1, we can form sum of 1 using integer combinations.

Example 3 — All Even Numbers

$ Input: nums = [4,6,10,12]

› Output: false

💡 Note: All numbers are even, so GCD(4,6,10,12) = 2 ≠ 1. Cannot form sum of 1 since all combinations will be even.

Constraints

1 ≤ nums.length ≤ 10³
1 ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 12 M Microsoft 8

The key insight is using Bézout's identity from number theory: an array is good if and only if the GCD of all its elements equals 1. Best approach is the GCD method with Time: O(n log(min)), Space: O(1).

Common Approaches

✓ Sort First

⏱️ Time: N/A Space: N/A

Brute Force - Try All Combinations

⏱️ Time: O(2ⁿ × M) Space: O(n)

For each subset of the array, try various integer multipliers for each element to see if any combination sums to 1. This approach explores the entire solution space but is computationally expensive.

Mathematical Approach - GCD

⏱️ Time: O(n log(min(nums))) Space: O(1)

By Bézout's identity, you can obtain sum of 1 using integer linear combinations if and only if the greatest common divisor (GCD) of all elements equals 1. This transforms the problem into a simple GCD calculation.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

static int subsets[1000][20];
static int subsetSizes[1000];
static int numSubsets;

void getCombinations(int n, int r, int start, int* current, int currentSize) {
    if (currentSize == r) {
        for (int i = 0; i < r; i++) {
            subsets[numSubsets][i] = current[i];
        }
        subsetSizes[numSubsets] = r;
        numSubsets++;
        return;
    }
    for (int i = start; i < n; i++) {
        current[currentSize] = i;
        getCombinations(n, r, i + 1, current, currentSize + 1);
    }
}

bool solution(int* nums, int numsSize) {
    // Try all possible subsets
    for (int r = 1; r <= numsSize; r++) {
        numSubsets = 0;
        int current[20];
        getCombinations(numsSize, r, 0, current, 0);
        
        for (int s = 0; s < numSubsets; s++) {
            // For small arrays, try limited multiplier combinations
            for (int mult_combination = 1; mult_combination < 100; mult_combination++) {
                int total = 0;
                for (int i = 0; i < subsetSizes[s]; i++) {
                    int idx = subsets[s][i];
                    // Simple multiplier strategy
                    int mult = (mult_combination >> i) & 1;
                    if (mult == 0) {
                        mult = -1;
                    }
                    total += nums[idx] * mult;
                }
                if (total == 1) {
                    return true;
                }
            }
        }
    }
    return false;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int size = 0;
    parseArray(line, nums, &size);
    
    bool result = solution(nums, size);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.4K Views

Medium Frequency

~15 min Avg. Time

856 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