> ## Documentation Index
> Fetch the complete documentation index at: https://leetcode-py.wisl.dev/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> leetcode-py is a Python LeetCode practice environment generator with one CLI: lcpy. It is not a service or platform.
> Each problem is a directory under leetcode/ with README.md, solution.py, test_solution.py, helpers.py, and playground.ipynb. lcpy gen creates them from JSON templates bundled with the package.
> Examples are backed by tests; copy them verbatim.

# Remove Comments Python Solution with Tests

> Tested Python solution for LeetCode 722 with 20 pytest cases. Generate a practice environment with lcpy.

LeetCode 722, [Medium](/catalog/medium). Topics: [Array](/catalog/topics/array), [String](/catalog/topics/string). [View on LeetCode](https://leetcode.com/problems/remove-comments/description/).

Generate this problem as a practice environment: tested reference solution, 20 [parametrized pytest cases](/practice/testing), and a playground notebook:

```bash theme={"theme":{"light":"github-light","dark":"github-dark"}}
lcpy gen -n 722   # by problem number
lcpy gen -s remove_comments   # by problem name
```

## Problem

Given a C++ program, remove comments from it. The program source is an array of strings `source` where `source[i]` is the `i<sup>th</sup>` line of the source code. This represents the result of splitting the original source code string by the newline character `'\n'`.

In C++, there are two types of comments, line comments, and block comments.

* The string `"//"` denotes a line comment, which represents that it and the rest of the characters to the right of it in the same line should be ignored.
* The string `"/*"` denotes a block comment, which represents that all characters until the next (non-overlapping) occurrence of `"*/"` should be ignored. (Here, occurrences happen in reading order: line by line from left to right.) To be clear, the string `"/*/"` does not yet end the block comment, as the ending would be overlapping the beginning.

The first effective comment takes precedence over others.

* For example, if the string `"//"` occurs in a block comment, it is ignored.
* Similarly, if the string `"/*"` occurs in a line or block comment, it is also ignored.

If a certain line of code is empty after removing comments, you must not output that line: each string in the answer list will be non-empty.

There will be no control characters, single quote, or double quote characters.

* For example, `source = "string s = "/* Not a comment. */";"` will not be a test case.

Also, nothing else such as defines or macros will interfere with the comments.

It is guaranteed that every open block comment will eventually be closed, so `"/*"` outside of a line or block comment always starts a new comment.

Finally, implicit newline characters can be deleted by block comments. Please see the examples below for details.

After removing the comments from the source code, return \<em>the source code in the same format\</em>.

### Examples

```
Input: source = ["/*Test program */", "int main()", "{ ", "  // variable declaration ", "int a, b, c;", "/* This is a test", "   multiline  ", "   comment for ", "   testing */", "a = b + c;", "}"]
Output: ["int main()","{ ","  ","int a, b, c;","a = b + c;","}"]
Explanation: The string /* denotes a block comment, including line 1 and lines 6-9. The string // denotes line 4 as comments. The line by line output code is visualized as below:
int main()
{

int a, b, c;
a = b + c;
}
```

```
Input: source = ["a/*comment", "line", "more_comment*/b"]
Output: ["ab"]
Explanation: The original source string is "a/*comment\nline\nmore_comment*/b". After deletion, the implicit newline characters are deleted, leaving the string "ab", which when delimited by newline characters becomes ["ab"].
```

### Constraints

* 1 \<= source.length \<= 100
* 0 \<= source\[i].length \<= 80
* source\[i] consists of printable ASCII characters.
* Every open block comment is eventually closed.
* There are no single-quote or double-quote in the input.

## Solution

Reference implementation from [solution.py on GitHub](https://github.com/wislertt/leetcode-py/blob/main/leetcode/remove_comments/solution.py), full suite in [test\_solution.py](https://github.com/wislertt/leetcode-py/blob/main/leetcode/remove_comments/test_solution.py):

```python theme={"theme":{"light":"github-light","dark":"github-dark"}}
class Solution:
    # Time: O(n) over the total number of characters
    # Space: O(n) for the output lines
    def remove_comments(self, source: list[str]) -> list[str]:
        result: list[str] = []
        in_block = False
        buf: list[str] = []

        for line in source:
            if not in_block:
                buf = []
            i = 0
            while i < len(line):
                if in_block:
                    end = line.find("*/", i)
                    if end == -1:
                        break
                    in_block = False
                    i = end + 2
                else:
                    line_c = line.find("//", i)
                    block_c = line.find("/*", i)
                    if line_c == -1 and block_c == -1:
                        buf.append(line[i:])
                        break
                    if line_c != -1 and (block_c == -1 or line_c < block_c):
                        buf.append(line[i:line_c])
                        break
                    buf.append(line[i:block_c])
                    in_block = True
                    i = block_c + 2
            if not in_block:
                code = "".join(buf)
                if code:
                    result.append(code)

        return result
```

## Complexity

| Time | Space |
| - | - |
| O(n) over the total number of characters | O(n) for the output lines |

## Tags


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.