Longest Harmonious Subsequence - Practice Coding Problems

Longest Harmonious Subsequence - Problem

A harmonious array is a special type of array where the difference between its maximum and minimum values is exactly 1. This creates a balanced, "harmonious" relationship between the elements.

Given an integer array nums, your task is to find the length of the longest harmonious subsequence among all possible subsequences.

A subsequence is derived from an array by deleting some or no elements without changing the order of the remaining elements. However, for this problem, order doesn't matter since we only care about the min/max difference.

Example: In array [1,3,2,2,5,2,3,7], one harmonious subsequence could be [3,2,2,2,3] (min=2, max=3, difference=1), which has length 5.

Goal: Return the length of the longest possible harmonious subsequence, or 0 if no harmonious subsequence exists.

Input & Output

example_1.py — Basic Harmonious Array

$ Input: [1, 3, 2, 2, 5, 2, 3, 7]

› Output: 5

💡 Note: The longest harmonious subsequence is [3, 2, 2, 2, 3] with length 5. The minimum value is 2, maximum is 3, and their difference is exactly 1, making it harmonious.

example_2.py — Single Element Types

$ Input: [1, 2, 3, 4]

› Output: 2

💡 Note: Multiple harmonious subsequences exist: [1,2], [2,3], [3,4]. Each has length 2, so we return 2 as the maximum length.

example_3.py — No Harmonious Subsequence

$ Input: [1, 1, 1, 1]

› Output: 0

💡 Note: All elements are identical, so max - min = 1 - 1 = 0, which doesn't satisfy the harmony condition (difference must be exactly 1). No harmonious subsequence exists.

Visualization

Tap to expand

Understanding the Visualization

Catalog Songs

Count how many songs we have at each rating level

Find Harmony

Look for adjacent ratings that can create harmonious playlists

Calculate Length

Sum the counts of harmonious rating pairs

Pick Longest

Choose the harmonious playlist with maximum songs

Key Takeaway

🎯 Key Insight: Only consecutive integers can form harmonious arrays, so we just need to count frequencies and check adjacent number pairs - no need to examine all possible subsequences!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array with O(1) hash operations

✓ Linear Growth

Space Complexity

O(n)

Hash map stores at most n unique elements with their frequencies

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 2 × 10⁴
-10⁹ ≤ nums[i] ≤ 10⁹
The array can contain duplicate elements
Subsequence order doesn't matter (we only care about min/max difference)

Asked in

G Google 45 a Amazon 32 f Meta 28 ⊞ Microsoft 25

The optimal approach uses a one-pass hash table to count element frequencies while simultaneously checking for harmonious pairs. For each element, we check if adjacent values (±1) exist and calculate potential harmonious subsequence lengths. This achieves O(n) time complexity with O(n) space, making it the most efficient solution.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Sorted Array)	O(n log n)	O(1)	Sort array and use two pointers to find harmonious groups
Two-Pass Hash Table	O(n)	O(n)	Count frequencies first, then find longest harmonious pair
Brute Force (Check All Subsequences)	O(2^n * n)	O(n)	Generate all possible subsequences and check which ones are harmonious
One-Pass Hash Table (Optimal)	O(n)	O(n)	Count frequencies and check for harmony in single pass

Two Pointers (Sorted Array) — Algorithm Steps

Sort the input array to group identical elements together
Use two pointers (left and right) to identify groups of identical elements
For each group, check if the next group's value differs by exactly 1
If so, calculate the combined length of both groups
Keep track of the maximum harmonious subsequence length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Array

Sort input to group identical elements together

Find Groups

Use pointers to identify groups of identical elements

Check Adjacent

Check if adjacent groups differ by exactly 1

Calculate Length

Sum lengths of harmonious adjacent groups

Code -

solution.c — C

#include <stdlib.h>

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int findLHS(int* nums, int numsSize) {
    if (numsSize == 0) return 0;
    
    qsort(nums, numsSize, sizeof(int), compare);
    int maxLength = 0;
    int left = 0;
    
    while (left < numsSize) {
        int right = left;
        // Find end of current group
        while (right < numsSize && nums[right] == nums[left]) {
            right++;
        }
        
        // Check if next group exists and differs by 1
        int nextRight = right;
        if (nextRight < numsSize && nums[nextRight] == nums[left] + 1) {
            // Find end of next group
            while (nextRight < numsSize && nums[nextRight] == nums[left] + 1) {
                nextRight++;
            }
            // Calculate harmonious subsequence length
            int currentLength = (right - left) + (nextRight - right);
            if (currentLength > maxLength) {
                maxLength = currentLength;
            }
        }
        
        left = right;
    }
    
    return maxLength;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting + O(n) for two-pointer traversal

⚡ Linearithmic

Space Complexity

O(1)

Only constant extra space (not counting sorting space)

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 2 × 10⁴
-10⁹ ≤ nums[i] ≤ 10⁹
The array can contain duplicate elements
Subsequence order doesn't matter (we only care about min/max difference)

38.5K Views

Medium Frequency

~15 min Avg. Time

1.5K 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

Two Pointers (Sorted Array) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler