Camelcase Matching solution and explanation

from typing import List

class Solution:
    def matches(self, query: str, pattern: str) -> bool:
        j = 0
        for c in query:
            if j < len(pattern) and c == pattern[j]:
                j += 1
            elif c.isupper():
                return False
        return j == len(pattern)

    def camelMatch(self, queries: List[str], pattern: str) -> List[bool]:
        return [self.matches(query, pattern) for query in queries]

import java.util.*;

class Solution {
    public boolean matches(String query, String pattern) {
        int j = 0;
        for (char c : query.toCharArray()) {
            if (j < pattern.length() && c == pattern.charAt(j)) {
                j++;
            } else if (Character.isUpperCase(c)) {
                return false;
            }
        }
        return j == pattern.length();
    }
    public List<Boolean> camelMatch(String[] queries, String pattern) {
        List<Boolean> result = new ArrayList<>();
        for (String query : queries) {
            result.add(matches(query, pattern));
        }
        return result;
    }
}

#include <vector>
#include <string>

class Solution {
public:
    bool matches(const std::string& query, const std::string& pattern) {
        int j = 0;
        for (char c : query) {
            if (j < pattern.length() && c == pattern[j]) {
                ++j;
            } else if (isupper(c)) {
                return false;
            }
        }
        return j == pattern.length();
    }
    std::vector<bool> camelMatch(std::vector<std::string>& queries, std::string pattern) {
        std::vector<bool> result;
        for (const std::string& query : queries) {
            result.push_back(matches(query, pattern));
        }
        return result;
    }
};

var camelMatch = function(queries, pattern) {
    const matches = (query, pattern) => {
        let j = 0;
        for (const char of query) {
            if (j < pattern.length && char === pattern[j]) {
                j++;
            } else if (char >= 'A' && char <= 'Z') {
                return false;
            }
        }
        return j === pattern.length;
    };
    return queries.map(query => matches(query, pattern));
};

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

bool matches(char* query, char* pattern) {
    int i = 0, j = 0;
    while (query[i]) {
        if (j < strlen(pattern) && query[i] == pattern[j]) {
            j++;
        } else if (query[i] >= 'A' && query[i] <= 'Z') {
            return false;
        }
        i++;
    }
    return j == strlen(pattern);
}

bool* camelMatch(char** queries, int queriesSize, char* pattern, int* returnSize) {
    *returnSize = queriesSize;
    bool* result = (bool*)malloc(queriesSize * sizeof(bool));
    for (int i = 0; i < queriesSize; i++) {
        result[i] = matches(queries[i], pattern);
    }
    return result;
}

using System;
using System.Collections.Generic;

public class Solution {
    public bool Matches(string query, string pattern) {
        int j = 0;
        foreach (char c in query) {
            if (j < pattern.Length && c == pattern[j]) {
                j++;
            } else if (char.IsUpper(c)) {
                return false;
            }
        }
        return j == pattern.Length;
    }

    public IList<bool> CamelMatch(string[] queries, string pattern) {
        List<bool> result = new List<bool>();
        foreach (string query in queries) {
            result.Add(Matches(query, pattern));
        }
        return result;
    }
}

import re

class Solution:
    def camelMatch(self, queries, pattern):
        regex_pattern = '^' + ''.join(c + '[a-z]*' for c in pattern) + '$'
        regex = re.compile(regex_pattern)
        return [bool(regex.match(query)) for query in queries]

var camelMatch = function(queries, pattern) {
    const regex = new RegExp(`^${pattern.split('').map(c => c + '[a-z]*').join('')}$`);
    return queries.map(query => regex.test(query));
};

function camelMatch(queries: string[], pattern: string): boolean[] {
    const check = (s: string, t: string) => {
        const m = s.length;
        const n = t.length;
        let i = 0;
        let j = 0;
        for (; j < n; ++i, ++j) {
            while (i < m && s[i] !== t[j] && s[i].codePointAt(0) >= 97) {
                ++i;
            }
            if (i === m || s[i] !== t[j]) {
                return false;
            }
        }
        while (i < m && s[i].codePointAt(0) >= 97) {
            ++i;
        }
        return i == m;
    };
    const ans: boolean[] = [];
    for (const q of queries) {
        ans.push(check(q, pattern));
    }
    return ans;
}

func camelMatch(queries []string, pattern string) (ans []bool) {
	check := func(s, t string) bool {
		m, n := len(s), len(t)
		i, j := 0, 0
		for ; j < n; i, j = i+1, j+1 {
			for i < m && s[i] != t[j] && (s[i] >= 'a' && s[i] <= 'z') {
				i++
			}
			if i == m || s[i] != t[j] {
				return false
			}
		}
		for i < m && s[i] >= 'a' && s[i] <= 'z' {
			i++
		}
		return i == m
	}
	for _, q := range queries {
		ans = append(ans, check(q, pattern))
	}
	return
}