Find Valid Pair of Adjacent Digits in String

Find Valid Pair of Adjacent Digits in String - Problem

🔢 Find Valid Pair of Adjacent Digits in String

You're given a string s containing only digits (0-9). Your task is to find the first valid pair of adjacent digits when scanning from left to right.

A valid pair must satisfy these conditions:

🔗 Adjacent: The two digits must be next to each other in the string
🚫 Different: The first digit ≠ second digit
📊 Count Match: Each digit appears in the entire string exactly as many times as its numeric value

Example: In string "1122", the pair "12" is valid because:

1 and 2 are adjacent and different
Digit '1' appears 2 times, but its value is 1 ❌
Digit '2' appears 2 times, and its value is 2 ✅

Return the first valid pair found, or an empty string if none exists.

Input & Output

example_1.py — Basic Valid Pair

$ Input: s = "1221"

› Output: "12"

💡 Note: Digits '1' appears 2 times (but should appear 1 time), '2' appears 2 times (should appear 2 times). The pair "12" at positions 0-1 has '1' with wrong count, so invalid. The pair "22" at positions 1-2 is skipped (same digits). The pair "21" at positions 2-3 is also invalid. Actually, no valid pair exists, so output should be empty string.

example_2.py — Multiple Valid Pairs

$ Input: s = "321"

› Output: "32"

💡 Note: Digit '3' appears 1 time (should appear 3 times - invalid), '2' appears 1 time (should appear 2 times - invalid), '1' appears 1 time (should appear 1 time - valid). Only '1' has correct count. No valid pairs exist.

example_3.py — No Valid Pairs

$ Input: s = "1111"

› Output: ""

💡 Note: All digits are the same, so no adjacent pairs of different digits exist. Return empty string.

Constraints

1 ≤ s.length ≤ 10³
s consists only of digits (0-9)
Adjacent means consecutive positions in the string
Count validation: digit d must appear exactly d times in the entire string

Visualization

Tap to expand

Understanding the Visualization

Count All Performers

Walk through the circus lineup once and count how many times each numbered performer appears

Create Performer Registry

Build a registry (hash table) with each performer's actual appearance count

Validate Adjacent Pairs

Check each adjacent pair of different performers against the registry

Quick Registry Lookup

Use the registry for instant validation - no need to recount performers

First Valid Pair Wins

Return the first pair where both performers have correct appearance counts

Key Takeaway

🎯 Key Insight: By building a frequency map first, we transform expensive O(n) counting operations into O(1) hash table lookups, achieving optimal O(n) time complexity with clean, maintainable code.

Asked in

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

The optimal approach uses a two-pass hash table: first count all digit frequencies in O(n), then validate each adjacent pair in O(n) using O(1) hash lookups. This avoids the O(n²) redundant counting of the brute force approach while maintaining linear time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table	O(n)	O(1)	First pass counts all digits, second pass checks each adjacent pair
Brute Force (Count For Each Pair)	O(n²)	O(1)	For each adjacent pair, count occurrences of both digits in the entire string

Two-Pass Hash Table — Algorithm Steps

First pass: Count frequency of each digit in the string
Store counts in a hash table/dictionary
Second pass: Check each adjacent pair
Skip pairs with identical digits
Use hash table to instantly check if both digits have valid counts
Return first valid pair found

Visualization

Tap to expand

Step-by-Step Walkthrough

First Pass - Count All

Build frequency map of all digits

Store Frequencies

Hash table contains count of each digit

Second Pass - Validate

Check each adjacent pair using stored counts

Quick Lookup

O(1) frequency lookup from hash table

Return First Valid

Stop when first valid pair is found

Code -

solution.c — C

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

char* solution(char* s) {
    int n = strlen(s);
    int freq[10] = {0}; // Frequency array for digits 0-9
    char* result = malloc(3);
    
    // First pass: count frequencies
    for (int i = 0; i < n; i++) {
        freq[s[i] - '0']++;
    }
    
    // Second pass: check adjacent pairs
    for (int i = 0; i < n - 1; i++) {
        char firstDigit = s[i];
        char secondDigit = s[i + 1];
        
        // Skip if digits are the same
        if (firstDigit == secondDigit) {
            continue;
        }
        
        // Check if both digits have valid counts
        int firstVal = firstDigit - '0';
        int secondVal = secondDigit - '0';
        
        if (freq[firstVal] == firstVal && freq[secondVal] == secondVal) {
            result[0] = firstDigit;
            result[1] = secondDigit;
            result[2] = '\0';
            return result;
        }
    }
    
    result[0] = '\0';
    return result;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    // Remove quotes and newline
    char* clean = s + 1;
    clean[strlen(clean) - 2] = '\0';
    
    char* result = solution(clean);
    printf("\"%s\"", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through the string: O(n) for counting + O(n) for checking pairs

✓ Linear Growth

Space Complexity

O(1)

Hash table stores at most 10 digit frequencies (0-9), which is constant space

✓ Linear Space

21.1K Views

Medium Frequency

~15 min Avg. Time

892 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

🔢 Find Valid Pair of Adjacent Digits in String

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Two-Pass Hash Table — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler