Crawler Log Folder - Practice Coding Problems

Crawler Log Folder - Problem

Imagine you're navigating through a file system using terminal commands! 🖥️

A web crawler keeps a detailed log every time it changes directories. You start in the main folder (root directory), and the crawler performs a series of folder operations based on these commands:

"../" - Move to the parent folder (go back one level). If you're already in the main folder, you stay put!
"./" - Stay in the current folder (do nothing)
"x/" - Move into a child folder named "x" (go deeper into the directory tree)

Given an array logs where each element represents a folder operation, determine the minimum number of steps needed to return to the main folder after all operations are complete.

Think of it like counting how many "cd ../" commands you need to get back to the root directory!

Input & Output

example_1.py — Basic Navigation

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

› Output: 2

💡 Note: Starting from main folder: d1/ (depth=1) → d2/ (depth=2) → ../ (depth=1) → d21/ (depth=2) → ./ (depth=2). Need 2 operations to return to main folder.

example_2.py — Stay in Main Folder

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

› Output: 0

💡 Note: Starting from main: d1/ (depth=1) → ../ (depth=0) → ../ (depth=0, can't go higher) → ../ (depth=0). Already in main folder.

example_3.py — Only Current Directory

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

› Output: 0

💡 Note: All operations keep us in the current folder (main folder). No movement occurs, so 0 operations needed to return.

Visualization

Tap to expand

Understanding the Visualization

Start at Main Folder

Initialize depth counter to 0, representing the main/root folder

Navigate Through Operations

For each folder operation: increment for child folders, decrement for parent folders, ignore current folder

Count Steps Home

The final depth value tells us how many '../' operations we need to return to main

Key Takeaway

🎯 Key Insight: We only need to track our current depth from the main folder, not the actual folder names or complete path!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all n operations with O(1) work per operation

✓ Linear Growth

Space Complexity

O(1)

Only uses a single integer variable regardless of input size

✓ Linear Space

Constraints

1 ≤ logs.length ≤ 10³
2 ≤ logs[i].length ≤ 10
logs[i] contains lowercase English letters, digits, '.', and '/'
logs[i] is guaranteed to be a valid folder operation

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 Apple 5

The optimal solution uses a simple depth counter approach. Instead of tracking actual folder names, we only maintain our distance from the main folder. Increment the counter for child folders, decrement for parent folders (minimum 0), and ignore current directory operations. This gives us O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Simulate Full Path)	O(n×m)	O(n×m)	Track the complete folder path as a list and manipulate it for each operation
Counter Approach (Optimal)	O(n)	O(1)	Track only the depth level using a simple counter - no need to store actual paths

Brute Force (Simulate Full Path) — Algorithm Steps

Initialize an empty list to represent the current folder path
For each operation in logs:
If '../', pop from path (if not empty)
If './', do nothing
Otherwise, append folder name to path
Return the length of the final path

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Empty Path

Start with empty path list representing main folder

Process Each Operation

Add/remove folder names from path based on operation type

Count Final Depth

Return the length of the final path list

Code -

solution.c — C

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

int minOperations(char logs[][10], int logsSize) {
    char path[1000][10];
    int pathSize = 0;
    
    for (int i = 0; i < logsSize; i++) {
        if (strcmp(logs[i], "../") == 0) {
            if (pathSize > 0) {
                pathSize--;
            }
        } else if (strcmp(logs[i], "./") == 0) {
            continue; // Stay in current folder
        } else {
            strcpy(path[pathSize], logs[i]);
            pathSize++;
        }
    }
    
    return pathSize;
}

int main() {
    int n;
    scanf("%d", &n);
    char logs[1000][10];
    for (int i = 0; i < n; i++) {
        scanf("%s", logs[i]);
    }
    printf("%d\n", minOperations(logs, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n×m)

n operations, each string operation takes O(m) time where m is average folder name length

✓ Linear Growth

Space Complexity

O(n×m)

Storing up to n folder names, each of average length m

⚡ Linearithmic Space

Constraints

1 ≤ logs.length ≤ 10³
2 ≤ logs[i].length ≤ 10
logs[i] contains lowercase English letters, digits, '.', and '/'
logs[i] is guaranteed to be a valid folder operation

58.0K Views

Medium Frequency

~8 min Avg. Time

2.2K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Simulate Full Path) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler