Crawler Log Folder - Practice Coding Problems

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

Understanding the Visualization

Input

Array of folder operations: child folders, parent (..), and stay (.)

Process

Track depth level as we navigate through folders

Output

Number of parent operations needed to return to main

Key Takeaway

🎯 Key Insight: Only the current depth matters, not the folder names - use a simple counter

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
✓ Stack Simulation	O(n)	O(n)	Use a stack to simulate the folder navigation
Counter Approach	O(n)	O(1)	Use a simple counter to track folder depth

Stack Simulation — Algorithm Steps

Initialize empty stack
For each operation: push folder names, pop for '../', ignore './'
Return stack size

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with empty stack representing main folder

Process Commands

Push folder names, pop for parent, ignore stay

Count Depth

Stack size equals operations needed to return

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(n)

Stack can hold up to n folder names in worst case

⚡ Linearithmic 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

Stack Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler