# Remove Adjacent Duplicate Runs of Length K Given a string `s` and an integer `k`, repeatedly remove any group of `k` equal adjacent characters. A removal can make characters on its two sides adjacent and trigger another removal. Return the final string after no more groups can be removed. For example: ```text s = "deeedbbcccbdaa", k = 3 output = "aa" ``` The original duplicate-removal case is `k = 2`; the implementation should handle the general `k` case directly. ### Constraints & Assumptions - `k` is at least `2`. - A run longer than `k` is processed according to the same repeated-removal rule. - The result must reflect all cascading removals, not just runs present in the original string. ### Clarifying Questions to Ask - Is `k` fixed for the lifetime of the program or supplied for each call? - What should be returned for an empty input string? - Are characters compared by exact code point and case? ```hint Store the current run length Keep each surviving character group together with its count so a new character updates only the top group. ``` ```hint Let removals expose prior state When a count reaches `k`, removing that group should reveal the previous group without rescanning the whole output. ``` ### Evaluation Criteria - Correct handling of cascading removals and runs longer than `k`. - A stack of character/count pairs or an equivalent one-pass representation. - Linear time in the input length and linear worst-case auxiliary space. - Edge cases including an empty string, no removable run, and complete removal. ### Extensions to Discuss - How does the implementation simplify when `k = 2`? - Can the result be produced online if the input arrives as a stream? - What changes if each character has its own removal threshold?