Camelcase Matching

Camelcase Matching - Problem

Given an array of strings queries and a string pattern, return a boolean array answer where answer[i] is true if queries[i] matches pattern, and false otherwise.

A query word queries[i] matches pattern if you can insert lowercase English letters into the pattern so that it equals the query. You may insert a character at any position in pattern or you may choose not to insert any characters at all.

Input & Output

Example 1 — Basic Matching

$ Input: queries = ["ForceFeedBack","ForYou","Fun"], pattern = "FB"

› Output: [true,false,false]

💡 Note: ForceFeedBack can be formed by inserting lowercase letters into FB (F+orce+B+ack). ForYou cannot because it has Y (uppercase) not in pattern. Fun cannot because it lacks B.

Example 2 — Exact Match

$ Input: queries = ["CompetitiveProgramming","FaceBook"], pattern = "CamelCase"

› Output: [false,false]

💡 Note: CompetitiveProgramming has P (uppercase) not in pattern. FaceBook has uppercase letters F,B that don't match pattern CamelCase.

Example 3 — Edge Case

$ Input: queries = ["AA","aaa"], pattern = "AAA"

› Output: [false,false]

💡 Note: AA is missing one A from pattern AAA. aaa has all lowercase but pattern requires uppercase A's.

Constraints

1 ≤ queries.length ≤ 100
1 ≤ queries[i].length ≤ 100
1 ≤ pattern.length ≤ 100
queries[i] and pattern consist of English letters

Visualization

Tap to expand

Asked in

G Google 35 f Facebook 28 a Amazon 22 M Microsoft 18

The key insight is that uppercase letters must match exactly in sequence, while lowercase letters can be inserted anywhere. Best approach uses two pointers to scan through query and pattern simultaneously. Time: O(n × m), Space: O(1)

Common Approaches

✓ Memoization

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

Brute Force Character Matching

⏱️ Time: O(n * m * k) Space: O(1)

Iterate through each query and check if it can be formed by inserting lowercase letters into the pattern. Use nested loops to check all possible character combinations.

Two Pointers Optimization

⏱️ Time: O(n * m) Space: O(1)

Use one pointer for the pattern and another for the query. Move both pointers when characters match, or move only query pointer for lowercase letters. Fail fast when uppercase letters don't match.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_QUERIES 1000
#define MAX_LEN 1000

char queries[MAX_QUERIES][MAX_LEN];
int query_count = 0;

void parseQueries(const char* line) {
    query_count = 0;
    if (strlen(line) <= 2) return; // Empty array []
    
    char* str = malloc(strlen(line) + 1);
    strcpy(str, line);
    
    // Remove [ and ]
    str[strlen(str) - 1] = '\0';
    char* token = str + 1;
    
    char* start = token;
    bool inQuotes = false;
    
    for (int i = 0; token[i]; i++) {
        if (token[i] == '"') {
            inQuotes = !inQuotes;
        } else if (token[i] == ',' && !inQuotes) {
            token[i] = '\0';
            
            // Extract query from start
            while (*start == ' ' || *start == '\t') start++;
            if (*start == '"') start++;
            char* end = start + strlen(start) - 1;
            while (end > start && (*end == ' ' || *end == '\t' || *end == '"')) {
                *end = '\0';
                end--;
            }
            
            strcpy(queries[query_count++], start);
            start = token + i + 1;
        }
    }
    
    // Handle last token
    while (*start == ' ' || *start == '\t') start++;
    if (*start == '"') start++;
    char* end = start + strlen(start) - 1;
    while (end > start && (*end == ' ' || *end == '\t' || *end == '"')) {
        *end = '\0';
        end--;
    }
    
    if (strlen(start) > 0) {
        strcpy(queries[query_count++], start);
    }
    
    free(str);
}

bool isMatch(const char* query, const char* pattern) {
    int i = 0, j = 0;
    int query_len = strlen(query);
    int pattern_len = strlen(pattern);
    
    while (i < query_len) {
        if (j < pattern_len && query[i] == pattern[j]) {
            i++;
            j++;
        } else if (islower(query[i])) {
            i++;
        } else {
            return false;
        }
    }
    
    return j == pattern_len;
}

int main() {
    char line1[10000], line2[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = '\0';
    line2[strcspn(line2, "\n")] = '\0';
    
    parseQueries(line1);
    
    printf("[");
    for (int i = 0; i < query_count; i++) {
        if (i > 0) printf(",");
        printf(isMatch(queries[i], line2) ? "true" : "false");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

32.0K Views

Medium Frequency

~25 min Avg. Time

890 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