How do I practice coding and algorithm questions?

Use PracHub's coding console to write, test, and debug your solutions in Python or JavaScript. View hints, test against sample inputs, and compare with official solutions.

What difficulty level is this coding question?

This is a medium difficulty Coding & Algorithms question, commonly asked during Technical Screen rounds at NVIDIA.

What role is this question designed for?

This question is commonly asked for Software Engineer candidates at NVIDIA during technical interviews.

Implement string compression and decompression

Quick Overview

This question evaluates proficiency in string manipulation, run-length encoding concepts, parsing numeric counts, and validation of encoded formats, including handling invalid inputs. It is in the Coding & Algorithms domain and is primarily a practical implementation task that also probes conceptual understanding of parsing, edge-case reasoning, and efficiency trade-offs.

Company: NVIDIA

Role: Software Engineer

Category: Coding & Algorithms

Difficulty: medium

Interview Round: Technical Screen

Implement two functions for a simple string compression format. - `compress(s)`: convert a string into groups of consecutive equal characters written as `<char><count>`. - `decompress(t)`: reconstruct the original string from that encoded form. Example: - `compress("aaabbccccd")` -> `"a3b2c4d1"` - `decompress("a3b2c4d1")` -> `"aaabbccccd"` Assume the input contains only English letters. Counts may have multiple digits, such as `a12`. Explain how you would handle invalid encoded input.

Quick Answer: This question evaluates proficiency in string manipulation, run-length encoding concepts, parsing numeric counts, and validation of encoded formats, including handling invalid inputs. It is in the Coding & Algorithms domain and is primarily a practical implementation task that also probes conceptual understanding of parsing, edge-case reasoning, and efficiency trade-offs.

Implement a function `solution(mode, text)` that supports two operations for a simple run-length encoding format. - If `mode == "compress"`, convert the input string into groups of consecutive equal letters written as `<char><count>`. - If `mode == "decompress"`, rebuild the original string from that encoded form. Examples: - `solution("compress", "aaabbccccd")` -> `"a3b2c4d1"` - `solution("decompress", "a3b2c4d1")` -> `"aaabbccccd"` Rules: - Input for compression contains only English letters (`A-Z` and `a-z`). - Counts in the encoded string may have multiple digits, such as `a12`. - For decompression, treat the encoded string as invalid unless it is a sequence of: `letter`, then a positive integer count, repeated. - Invalid encoded input should return `None`. - A count of `0` or any count with leading zeros (such as `a03`) is invalid. - The empty string is valid for both operations and should return the empty string.

Constraints

0 <= len(text) <= 100000
For `compress`, `text` contains only English letters `A-Z` and `a-z`
For `decompress`, a valid encoding alternates `letter` + `positive integer count`
For valid decompression inputs, the total decompressed output length will not exceed 100000

Examples

Input: ("compress", "aaabbccccd")

Expected Output: "a3b2c4d1"

Explanation: The runs are `a x 3`, `b x 2`, `c x 4`, and `d x 1`.

Input: ("decompress", "a3b2c4d1")

Expected Output: "aaabbccccd"

Explanation: Expand each letter by its count: `a3 -> aaa`, `b2 -> bb`, `c4 -> cccc`, `d1 -> d`.

Input: ("compress", "")

Expected Output: ""

Explanation: An empty string compresses to an empty string.

Input: ("decompress", "a12B3")

Expected Output: "aaaaaaaaaaaaBBB"

Explanation: `a12` expands to 12 lowercase `a` characters and `B3` expands to 3 uppercase `B` characters.

Input: ("decompress", "ab2")

Expected Output: None

Explanation: Invalid: after `a`, a numeric count is required, but `b` appears immediately.

Input: ("decompress", "a03")

Expected Output: None

Explanation: Invalid: counts cannot start with `0`, so leading zeros are not allowed.

Hints

For compression, scan left to right and count the length of each run of identical characters.
For decompression, after reading one letter, keep reading digits until the next letter to build the full count. Make sure the count exists and does not start with `0`.

Quick Overview