Domain 1EasyCORE

Crawler Log Folder

The problem involves simulating folder navigation based on a series of log entries. The goal is to determine the minimum number of operations needed to return to the main folder after processing all log entries.

Domain: Easy•Updated: 2026-08-31
#Algorithms#LeetCode#qwen2.5-coder:14b#Stack

1598. Crawler Log Folder

Model: qwen2.5-coder:14b
Topics: Stack
FAANG asked: 0
Acceptance rate: 63.7%


Problem Breakdown

The problem involves simulating folder navigation based on a series of log entries. The goal is to determine the minimum number of operations needed to return to the main folder after processing all log entries.

Inputs:

  • A list of strings logs where each string represents an operation:
    • "../": Move up one directory level.
    • "./": Stay in the current directory.
    • "x/": Move into a subdirectory named x.

Outputs:

  • An integer representing the minimum number of operations needed to return to the main folder.

Implicit Constraints and Edge Cases:

  • The initial directory is always the main folder.
  • If an operation is "../" and the current directory is already the main folder, it remains unchanged.
  • The length of logs is between 1 and 1000.
  • Each log entry has a length between 2 and 10 characters.

Intuition

A brute-force approach would involve simulating each operation step-by-step and keeping track of the current directory level. However, this approach could be inefficient in terms of both time and space complexity.

The key insight is to use a counter instead of a stack data structure to simulate the folder navigation. Each time we encounter a "../" operation, we decrement the counter (move up one directory). For any other operation, we increment the counter (move into a subdirectory or stay in place).

This approach ensures that we efficiently manage the current directory level with constant time operations for each log entry.

Approach

  1. Initialize a counter to 0 to represent the directory levels.
  2. Iterate through each log entry:
    • If the log entry is "../", decrement the counter if it’s greater than 0 (move up one directory).
    • If the log entry is "./", do nothing (stay in place).
    • For any other log entry, increment the counter (move into a subdirectory).
  3. The value of the counter at the end of processing all logs represents the number of operations needed to return to the main folder.

Complexity Analysis

  • Time Complexity: O(n), where n is the length of the logs list. Each operation (increment, decrement) on the counter takes constant time.
  • Space Complexity: O(1), as we are using a single integer counter instead of a stack.

Solution

def minOperations(logs):
    depth = 0
    
    for log in logs:
        if log == "../":
            depth = max(depth - 1, 0)
        elif log != "./":
            depth += 1
    
    return depth

Edge Cases Handled

  • Empty Input: If logs is empty, the function returns 0 since no operations are performed.
  • Main Directory Operations: "../" when already in the main directory does nothing.
  • Multiple "../" Operations: If there are more "../" operations than directories, the counter remains at 0, and the function correctly returns 0.