## Group Events by an Ordered Attribute List ### Problem Implement `groupEventCounts(fieldNames, events, groupBy) -> resultJson`. Each row in `events` is a portable array encoding of one event object: `events[i][j]` is the value of field `fieldNames[j]`. Group the events first by `groupBy[0]`, then by `groupBy[1]`, and so on. The conceptual result is a nested map whose depth equals `groupBy.length` and whose leaves are occurrence counts. Return that nested map as one canonical compact JSON string. This string representation preserves the requested dynamic map depth while giving Python, JavaScript, Java, and C++ the same exact return type. ### Portable Contract - `fieldNames` contains between 1 and 12 unique strings. - `events` contains between 0 and 8,000 rows. Every row has exactly `fieldNames.length` string values. - `groupBy` contains between 1 and `fieldNames.length` unique names, and every name occurs in `fieldNames`. - Field names and event values contain 1 to 24 characters drawn only from lowercase ASCII letters, decimal digits, and underscore. They therefore require no escaping inside JSON object keys. - Every event contributes exactly one to the leaf reached by its values in `groupBy` order. - The returned JSON contains no whitespace. Object keys are sorted in ascending ASCII lexicographic order at every level. Counts are unquoted decimal integers. Empty `events` returns `"{}"`. - Do not modify the inputs. - Let `B` be the compact UTF-8 JSON byte length of `[fieldNames,events,groupBy]`, counting every bracket, comma, quote, and character byte. Inputs satisfy `B <= 96,000`. - Let `R` be the compact UTF-8 JSON byte length of the returned string, including the outer serialization's required escaping of its quotes. Inputs guarantee `R <= 96,000`, so serialized input plus result is at most `192,000` bytes. - For `e = events.length`, `g = groupBy.length`, and `u` total distinct nested map entries, target `O(e * g + u log u)` time and `O(u + g)` auxiliary space, excluding input storage. All containers are homogeneous strings: - Python: `def groupEventCounts(fieldNames: list[str], events: list[list[str]], groupBy: list[str]) -> str` - JavaScript: `function groupEventCounts(fieldNames, events, groupBy)` returns a string. - Java: `String groupEventCounts(List<String> fieldNames, List<List<String>> events, List<String> groupBy)` - C++: `string groupEventCounts(const vector<string>& fieldNames, const vector<vector<string>>& events, const vector<string>& groupBy)` ```hint Resolve requested fields once Map every grouping name to its row position before visiting the event rows, rather than searching `fieldNames` for every value. ``` ```hint Separate counting from encoding Build the nested counts first, then serialize each map level by visiting its keys in the required order. ``` ### Examples ```text fieldNames = ["type", "country"] events = [["type1", "us"], ["type1", "uk"], ["type1", "us"], ["type2", "fr"]] groupBy = ["type", "country"] resultJson contents = {"type1":{"uk":1,"us":2},"type2":{"fr":1}} ``` ```text fieldNames = ["browser", "country"] events = [] groupBy = ["country"] resultJson contents = {} ``` ### Discussion Requirements 1. State how an encoded event row is mapped back to its named fields. 2. Explain why the order of `groupBy` determines the nested-map shape and why repeated event combinations increment one leaf. 3. Cover empty events, one grouping attribute, several attributes, repeated values, and invalid field names even though valid inputs exclude them. 4. Explain how sorted keys and the restricted character set make the returned JSON deterministic across all four languages.