Introduction

LeetCode 2784 – Check if Array is Good is a beginner-friendly array and hashing problem that tests your understanding of:

1. Frequency counting
2. HashMap usage
3. Array validation
4. Permutation logic
5. Edge case handling

Although the problem looks simple initially, many candidates fail because they misunderstand the exact structure of the required array.

This problem is commonly asked to test:

1. Attention to detail
2. Logical validation
3. Counting techniques
4. Hashing fundamentals

Problem Link

🔗 https://leetcode.com/problems/check-if-array-is-good/

Problem Statement

An array is considered good if it is a permutation of:

Meaning:

1. Numbers from:

appear exactly once.

1. Number:

appears exactly twice.

You need to return:

if the given array is good, otherwise:

Understanding the Pattern

A valid good array must follow:

Examples:

Invalid examples:

Key Observations

Observation 1

The maximum element determines:

Observation 2

Array size must be:

because:

Observation 3

Frequency conditions:

Brute Force Approach

Idea

1. Sort array
2. Compare with expected array
3. Return result

Brute Force Algorithm

Step 1

Find maximum element:

Step 2

Create expected array:

Step 3

Sort both arrays and compare.

Brute Force Complexity

Time Complexity

due to sorting.

Space Complexity

Optimized HashMap Approach

Instead of sorting:

1. Count frequencies directly
2. Validate conditions

This makes the solution faster and cleaner.

Intuition Behind HashMap Solution

We store frequency of every number.

Then verify:

1. Maximum element appears twice
2. Every other number appears once
3. Array length equals:

Java HashMap Solution

Dry Run

Input

Step 1 – Find Maximum

Maximum element:

So:

Step 2 – Length Check

Expected length:

Actual length:

Valid.

Step 3 – Frequency Count

Frequency map:

Step 4 – Validate Conditions

1. Numbers 1 and 2 appear once ✅
2. Number 3 appears twice ✅

Return:

Edge Cases

Case 1

Invalid because:

Case 2

Valid.

Case 3

Invalid because:

Expected:

Actually valid.

Case 4

Invalid because:

Optimized Alternative Using Sorting

Another clean solution:

1. Sort array
2. Verify:

for all except last.

1. Last two elements should be equal.

Java Sorting Solution

Time Complexity Analysis

HashMap Solution

Time Complexity

Space Complexity

Sorting Solution

Time Complexity

Space Complexity

excluding sorting overhead.

HashMap vs Sorting

Interview Explanation

In interviews, explain:

A good array must follow the exact pattern [1,2,3,...,n,n]. The maximum element determines n, and frequency counting helps verify whether all required numbers appear correctly.

This demonstrates strong understanding of:

1. Frequency counting
2. Validation logic
3. Edge case handling

Common Mistakes

1. Forgetting Length Check

Always verify:

2. Ignoring Missing Numbers

Array must contain:

completely.

3. Wrong Frequency Validation

Only maximum element should appear twice.

All others must appear once.

FAQs

Q1. Why does maximum element determine n?

Because:

always ends with:

Q2. Why should array size be n + 1?

Because:

Q3. Which approach is better?

HashMap solution is faster.

Sorting solution is simpler.

Q4. Is this problem important for interviews?

Yes.

It tests:

1. Hashing
2. Validation logic
3. Edge case thinking

Related Problems

After mastering this problem, practice:

1. Contains Duplicate
2. Find All Duplicates in an Array
3. Valid Anagram

Conclusion

LeetCode 2784 is a great beginner-friendly hashing problem.

It teaches:

1. Frequency counting
2. Validation logic
3. HashMap usage
4. Edge case handling

The key insight is:

A good array must exactly match the structure [1,2,3,...,n,n].

Once you understand this pattern, the problem becomes straightforward and easy to implement.