Crawler Log Folder

Crawler Log Folder - Problem

The Leetcode file system keeps a log each time some user performs a change folder operation.

The operations are described below:

"../": Move to the parent folder of the current folder. (If you are already in the main folder, remain in the same folder).
"./": Remain in the same folder.
"x/": Move to the child folder named x (This folder is guaranteed to always exist).

You are given a list of strings logs where logs[i] is the operation performed by the user at the ith step.

The file system starts in the main folder, then the operations in logs are performed.

Return the minimum number of operations needed to go back to the main folder after the change folder operations.

Input & Output

Example 1 — Basic Navigation

$ Input: logs = ["d1/","d2/","../","d21/","./"]

› Output: 2

💡 Note: Start at main → d1 (depth 1) → d2 (depth 2) → back to d1 (depth 1) → d21 (depth 2) → stay in d21 (depth 2). Need 2 operations to return to main.

Example 2 — Stay at Main

$ Input: logs = ["d1/","../","../","../"]

› Output: 0

💡 Note: Start at main → d1 (depth 1) → back to main (depth 0) → try to go up but stay at main (depth 0) → stay at main (depth 0). Already at main, need 0 operations.

Example 3 — Only Stay Operations

$ Input: logs = ["./","./","./"]

› Output: 0

💡 Note: All operations are stay commands, remain at main folder throughout. Need 0 operations to return.

Constraints

1 ≤ logs.length ≤ 10³
2 ≤ logs[i].length ≤ 10
logs[i] contains lowercase English letters, digits, '.', and '/'
logs[i] follows the format described in the statement

Visualization

Tap to expand

Asked in

A Amazon 15 M Microsoft 8

The key insight is that we only need to track the current folder depth, not the actual folder names. The optimal approach uses a simple counter: increment for child folders, decrement for parent operations (but never below 0), and ignore stay operations. Time: O(n), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Counter Approach	O(n)	O(1)	Use a simple counter to track folder depth
Stack Simulation	O(n)	O(n)	Use a stack to simulate the folder navigation

Counter Approach — Algorithm Steps

Initialize depth counter to 0
For each operation: increment for folders, decrement for '../', ignore './'
Return final depth

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with depth = 0 (main folder)

Process Operations

Increment for folders, decrement for parent, ignore stay

Return Depth

Final depth equals operations needed

Code -

solution.c — C

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

int solution(char logs[][20], int logsSize) {
    int depth = 0;
    for (int i = 0; i < logsSize; i++) {
        if (strcmp(logs[i], "../") == 0) {
            if (depth > 0) {
                depth--;
            }
        } else if (strcmp(logs[i], "./") != 0) {
            depth++;
        }
    }
    return depth;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for this problem
    char logs[100][20];
    int logsSize = 0;
    
    char* token = strtok(line, "[],\"\n");
    while (token != NULL && logsSize < 100) {
        if (strlen(token) > 0 && token[0] != ' ') {
            strcpy(logs[logsSize], token);
            logsSize++;
        }
        token = strtok(NULL, "[],\"\n");
    }
    
    printf("%d\n", solution(logs, logsSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all log operations

✓ Linear Growth

Space Complexity

O(1)

Only uses a single integer variable for depth tracking

✓ Linear Space

34.0K Views

Medium Frequency

~10 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

Counter Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler