Remove Comments - Practice Coding Problems

Remove Comments - Problem

Array String Medium

Remove Comments from C++ Source Code

Imagine you're building a code preprocessor that needs to clean up C++ source code by removing all comments before compilation. You're given a C++ program as an array of strings, where each string represents a line of source code.

Your task is to remove two types of comments:

🔸 Line comments (//): Everything from // to the end of that line should be removed
🔸 Block comments (/* ... */): Everything between /* and */ should be removed, even across multiple lines

Important rules:
• Comments inside other comments are ignored (e.g., // inside a block comment)
• Empty lines after removing comments should be excluded from output
• Block comments can span multiple lines and effectively "delete" newlines
• The string /**/ does NOT end a block comment (overlapping issue)

Goal: Return the cleaned source code with all comments removed, maintaining the same array format but excluding empty lines.

Example:

["/*Test program */", "int main(){", "    // variable declaration", "    int a = 1;", "    /* comment */", "    return 0;", "}"]

becomes ["int main(){", " int a = 1;", " return 0;", "}"]

Input & Output

basic_comments.py — Python

$ Input: source = ["/*Test program */", "int main(){", " // variable declaration", " int a = 1;", " /* comment */", " return 0;", "}"]

› Output: ["int main(){", " int a = 1;", " return 0;", "}"]

💡 Note: The first line is entirely a block comment, so it's removed. The line comment removes everything after //, and the single-line block comment is removed while preserving the rest of the line (which becomes just whitespace and is excluded).

multiline_block.py — Python

$ Input: source = ["a/*comment", "line", "more_comment*/b"]

› Output: ["ab"]

💡 Note: The block comment spans multiple lines, effectively removing the newline characters. The result concatenates 'a' from the first line with 'b' from the third line into a single line 'ab'.

nested_comments.py — Python

$ Input: source = ["struct Node{", " /*// Constructor */", " int val;", " /* // Another comment", " with multiple lines */", " int next;", "};"]

› Output: ["struct Node{", " int val;", " int next;", "};"]

💡 Note: Line comments inside block comments are ignored. The '//' inside the block comments don't start new line comments because they're already inside block comments.

Constraints

1 ≤ source.length ≤ 100
0 ≤ source[i].length ≤ 80
source[i] consists of printable ASCII characters
Every open block comment will eventually be closed
There are no single quotes, double quotes, or control characters in the source code

Visualization

Tap to expand

Understanding the Visualization

Start in Normal State

Begin processing characters in normal code mode

Detect Comment Patterns

Look for '//' or '/*' patterns while in normal state

Enter Comment State

Switch to appropriate comment state and skip characters

Exit Comment State

Return to normal state when comment ends (newline for //, */ for block)

Build Result

Collect non-comment characters and form cleaned source code

Key Takeaway

🎯 Key Insight: Use a finite state machine to elegantly handle the different modes of text processing, ensuring proper comment removal while preserving code structure.

Asked in

G Google 23 ⊞ Microsoft 18 a Amazon 15 f Facebook 12

The optimal approach uses a finite state machine to track three states: normal code, line comment, and block comment. Process each character while maintaining state, building the result by collecting non-comment characters. The key insight is that block comments can span multiple lines and effectively remove newline characters, while line comments only affect the current line. Time complexity is O(n) where n is the total number of characters.

Common Approaches

Approach	Time	Space	Notes
✓ Character-by-Character State Tracking	O(n)	O(n)	Process each character individually while tracking comment state

Character-by-Character State Tracking — Algorithm Steps

Initialize a flag to track if we're in a block comment
For each line, iterate through each character
Check for comment start patterns (// or /*)
Check for block comment end pattern (*/)
Build current line by skipping commented characters
Add non-empty lines to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize State

Start with inBlock = false, empty currentLine

Process Characters

Check each character for comment patterns

Handle Comments

Skip characters inside comments, collect others

Build Result

Add non-empty lines to result array

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char** removeComments(char** source, int sourceSize, int* returnSize) {
    char** result = malloc(sourceSize * sizeof(char*));
    *returnSize = 0;
    int inBlock = 0;
    char* currentLine = malloc(10000 * sizeof(char));
    currentLine[0] = '\0';
    
    for (int lineIdx = 0; lineIdx < sourceSize; lineIdx++) {
        char* line = source[lineIdx];
        int i = 0;
        int len = strlen(line);
        
        while (i < len) {
            if (!inBlock) {
                if (i < len - 1 && line[i] == '/' && line[i + 1] == '*') {
                    inBlock = 1;
                    i += 2;
                } else if (i < len - 1 && line[i] == '/' && line[i + 1] == '/') {
                    break; // Rest of line is comment
                } else {
                    int currentLen = strlen(currentLine);
                    currentLine[currentLen] = line[i];
                    currentLine[currentLen + 1] = '\0';
                    i++;
                }
            } else { // inBlock is true
                if (i < len - 1 && line[i] == '*' && line[i + 1] == '/') {
                    inBlock = 0;
                    i += 2;
                } else {
                    i++;
                }
            }
        }
        
        if (!inBlock && strlen(currentLine) > 0) {
            result[*returnSize] = malloc((strlen(currentLine) + 1) * sizeof(char));
            strcpy(result[*returnSize], currentLine);
            (*returnSize)++;
            currentLine[0] = '\0';
        }
    }
    
    free(currentLine);
    return result;
}

int main() {
    char* source[] = {"int main(){}", "// comment"};
    int returnSize;
    char** result = removeComments(source, 2, &returnSize);
    for (int i = 0; i < returnSize; i++) {
        printf("%s\n", result[i]);
    }
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Where n is the total number of characters across all lines, as we process each character once

✓ Linear Growth

Space Complexity

O(n)

For storing the result array, which in worst case could be similar size to input

⚡ Linearithmic Space

24.7K Views

Medium Frequency

~25 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Character-by-Character State Tracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler