Remove Comments - Practice Coding Problems

Remove Comments - Problem

Array String Medium

Given a C++ program, remove comments from it. The program source is an array of strings source where source[i] is the i-th line of the source code.

In C++, there are two types of comments:

Line 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.
Block comments: The string /* denotes a block comment, which represents that all characters until the next occurrence of */ should be ignored.

Important rules:

The first effective comment takes precedence over others
If // occurs in a block comment, it is ignored
If /* occurs in a line or block comment, it is also ignored
If a line becomes empty after removing comments, do not output that line
Block comments can span multiple lines and delete implicit newline characters

Return the source code with comments removed in the same format.

Input & Output

Example 1 — Mixed Comments

$ Input: source = ["/*Test program */", "int main()", "{ ", " // variable declaration ", "int a, b, c;", "/* This is a long ", " comment to test ", " if the comment is", " removed properly.*/", "a = b + c;", "}"]

› Output: ["int main()","{ ","int a, b, c;","a = b + c;","}"]

💡 Note: Block comment /*Test program */ removed from first line making it empty. Line comment // variable declaration removes rest of line. Multi-line block comment removed completely. Only actual code lines remain.

Example 2 — Block Comment Across Lines

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

› Output: ["ab"]

💡 Note: Block comment spans multiple lines from 'a/*comment' through 'more_comment*/b'. After removing the comment content, 'a' and 'b' are concatenated since the block comment removal eliminates the newline characters in between.

Example 3 — Line Comment Only

$ Input: source = ["class Test {", " public static void main() {", " // This line is comment", " System.out.println(\"Hello\");", " }", "}"]

› Output: ["class Test {"," public static void main() {"," System.out.println(\"Hello\");"," ","}"]

💡 Note: Line comment '// This line is comment' removes the entire line. All other lines containing actual code are preserved exactly as they are.

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 string literals with quotes

Visualization

Tap to expand

Understanding the Visualization

Input Code

C++ source with line and block comments

Comment Filtering

Remove // and /* */ comment regions

Clean Output

Array of non-empty code lines only

Key Takeaway

🎯 Key Insight: Use a state machine to track block comment regions while processing characters sequentially

Asked in

G Google 15 M Microsoft 12 a Amazon 8 f Facebook 6

The key insight is to use a state machine to track whether we're inside a block comment while processing each character. The optimal approach processes all characters in a single pass, maintaining block comment state across lines and filtering out comment content. Time: O(n×m), Space: O(n×m) where n is number of lines and m is average line length.

Common Approaches

Approach	Time	Space	Notes
✓ Character-by-Character State Machine	O(n × m)	O(n × m)	Process each character while tracking comment state
Single Pass with String Building	O(n × m)	O(n × m)	Efficiently process all lines in one pass with optimized string operations

Character-by-Character State Machine — Algorithm Steps

Step 1: Process each line character by character
Step 2: Track if currently inside block comment
Step 3: Handle // and /* patterns appropriately
Step 4: Build result lines, skipping empty ones

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Each Line

Go through characters, tracking comment state

Handle Comments

Skip content inside // and /* */ regions

Build Result

Keep only non-empty lines with actual code

Code -

solution.c — C

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

char** solution(char** source, int sourceSize, int* returnSize) {
    char** result = (char**)malloc(sourceSize * sizeof(char*));
    *returnSize = 0;
    bool inBlock = false;
    char currentLine[1000] = "";
    int currentLen = 0;
    
    for (int lineIdx = 0; lineIdx < sourceSize; lineIdx++) {
        char* line = source[lineIdx];
        int i = 0;
        
        while (i < strlen(line)) {
            if (!inBlock) {
                if (i < strlen(line) - 1 && strncmp(&line[i], "//", 2) == 0) {
                    break; // Rest of line is comment
                } else if (i < strlen(line) - 1 && strncmp(&line[i], "/*", 2) == 0) {
                    inBlock = true;
                    i += 2;
                    continue;
                } else {
                    currentLine[currentLen++] = line[i];
                }
            } else { // inBlock
                if (i < strlen(line) - 1 && strncmp(&line[i], "*/", 2) == 0) {
                    inBlock = false;
                    i += 2;
                    continue;
                }
            }
            i++;
        }
        
        if (!inBlock) {
            currentLine[currentLen] = '\0';
            // Check if line has non-space characters
            bool hasContent = false;
            for (int j = 0; j < currentLen; j++) {
                if (currentLine[j] != ' ' && currentLine[j] != '\t') {
                    hasContent = true;
                    break;
                }
            }
            
            if (hasContent) {
                result[*returnSize] = (char*)malloc((currentLen + 1) * sizeof(char));
                strcpy(result[*returnSize], currentLine);
                (*returnSize)++;
            }
            
            currentLen = 0;
            memset(currentLine, 0, sizeof(currentLine));
        }
    }
    
    return result;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    input[strcspn(input, "\n")] = 0;
    
    // Simple parsing for test - assume format ["line1","line2",...]
    char* source[100];
    int sourceSize = 0;
    
    char* ptr = input + 1; // Skip opening bracket
    while (*ptr && *ptr != ']') {
        if (*ptr == '"') {
            ptr++; // Skip opening quote
            char* start = ptr;
            while (*ptr && *ptr != '"') ptr++;
            
            int len = ptr - start;
            source[sourceSize] = (char*)malloc((len + 1) * sizeof(char));
            strncpy(source[sourceSize], start, len);
            source[sourceSize][len] = '\0';
            sourceSize++;
            
            if (*ptr == '"') ptr++; // Skip closing quote
        }
        if (*ptr == ',') ptr++; // Skip comma
        while (*ptr == ' ') ptr++; // Skip spaces
    }
    
    int returnSize;
    char** result = solution(source, sourceSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("\"%s\"", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

n lines × m average characters per line

✓ Linear Growth

Space Complexity

O(n × m)

Result array and temporary string building

⚡ Linearithmic Space

32.0K Views

Medium Frequency

~25 min Avg. Time

487 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 Machine — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler