ಕ್ರಾಲರ್ ಲಾಗ್ ಫೋಲ್ಡರ್ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರ


ತೊಂದರೆ ಮಟ್ಟ ಸುಲಭ
ಆಗಾಗ್ಗೆ ಕೇಳಲಾಗುತ್ತದೆ ಮರ್ಕಾರಿ
ಸ್ಟಾಕ್

ಸಮಸ್ಯೆ ಹೇಳಿಕೆ

ಈ ಸಮಸ್ಯೆಯಲ್ಲಿ, ನಾವು ಫೋಲ್ಡರ್ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ನಮ್ಮ ಸ್ಥಾನವನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುತ್ತಿದ್ದೇವೆ. ನಾವು ಆರಂಭದಲ್ಲಿ ರೂಟ್ ಫೋಲ್ಡರ್ ಅಥವಾ ಈ ಸಿಸ್ಟಮ್ನ ಮುಖ್ಯ ಫೋಲ್ಡರ್ನಲ್ಲಿದ್ದೇವೆ.
ನಾವು ಮೂಲತಃ ಇಲ್ಲಿ 3 ರೀತಿಯ ಆಜ್ಞೆಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ. ಆಜ್ಞೆಗಳು ಸ್ಟ್ರಿಂಗ್ ರೂಪದಲ್ಲಿರುತ್ತವೆ, ಇದರಲ್ಲಿ ಪ್ರತಿ ಸ್ಟ್ರಿಂಗ್ ಎಂದರೆ ಆಜ್ಞೆಯಾಗಿದೆ.

  •  “../” ಎಂದರೆ ಪ್ರಸ್ತುತ ಫೋಲ್ಡರ್‌ನ ಮೂಲ ಫೋಲ್ಡರ್‌ಗೆ ಹೋಗಿ (ಈಗಾಗಲೇ ಮೂಲ ಫೋಲ್ಡರ್‌ನಲ್ಲಿದ್ದರೆ ಎಲ್ಲಿಯೂ ಹೋಗಬೇಡಿ).
  •  “./” ಪ್ರಸ್ತುತ ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ಉಳಿಯಿರಿ.
  •  X ಹೆಸರನ್ನು ಹೊಂದಿರುವ ಪ್ರಸ್ತುತ ಫೋಲ್ಡರ್‌ನ ಮಕ್ಕಳ ಫೋಲ್ಡರ್‌ಗೆ “x /” ಹೋಗಿ.

ಮೇಲಿನ 3 ಆಜ್ಞೆಗಳ ಸಂಯೋಜನೆಯಾದ ಆಜ್ಞೆಗಳ ಅನುಕ್ರಮವನ್ನು ನಮಗೆ ನೀಡಲಾಗಿದೆ. ಕೊಟ್ಟಿರುವ ಆಜ್ಞೆಗಳನ್ನು ಮೊದಲೇ ರೂಪಿಸಿದ ನಂತರ ರೂಟ್ ಫೋಲ್ಡರ್‌ಗೆ ಹಿಂತಿರುಗಲು ನಾವು ಕನಿಷ್ಟ ಸಂಖ್ಯೆಯ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಕಂಡುಹಿಡಿಯಬೇಕು.
ಉದಾ
ದಾಖಲೆಗಳು = [“d1 /”, ”d2 /","../”, ”d21 /","./”]

ಕ್ರಾಲರ್ ಲಾಗ್ ಫೋಲ್ಡರ್ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರ
ನಾವು ರೂಟ್ ಫೋಲ್ಡರ್‌ನಿಂದ 2 ನೇ ಆಳದಲ್ಲಿದ್ದೇವೆ. ಆದ್ದರಿಂದ, ನಮ್ಮ ಉತ್ತರ 2 ಆಗಿರುತ್ತದೆ.

ಉದಾಹರಣೆ

logs = ["d1/","d2/","../","d21/","./"]
2

ವಿವರಣೆ:

ಈ ಬದಲಾವಣೆ ಫೋಲ್ಡರ್ ಕಾರ್ಯಾಚರಣೆಯನ್ನು “../” 2 ಬಾರಿ ಬಳಸಿ ಮತ್ತು ಮುಖ್ಯ ಫೋಲ್ಡರ್‌ಗೆ ಹಿಂತಿರುಗಿ.

logs = ["d1/","d2/","./","d3/","../","d31/"]
3

ಅಪ್ರೋಚ್ 1 (ಸ್ಟಾಕ್ ಬಳಸಿ)

ನಾವು ಫೈಲ್ ಹೆಸರುಗಳ ಸಂಗ್ರಹವನ್ನು ಬಳಸಬಹುದು. ಆರಂಭದಲ್ಲಿ ನಮ್ಮ ಸ್ಟಾಕ್ ಖಾಲಿಯಾಗಿದೆ. ನಾವು ಸಬ್‌ಫೋಲ್ಡರ್‌ಗೆ ಹೋಗಬೇಕಾದಾಗಲೆಲ್ಲಾ ಸಬ್‌ಫೋಲ್ಡರ್‌ನ ಹೆಸರನ್ನು ಸ್ಟ್ಯಾಕ್‌ಗೆ ತಳ್ಳಲಾಗುತ್ತದೆ. ಹೀಗಾಗಿ, ನಾವು ಪ್ರಸ್ತುತ ಇರುವ ಫೋಲ್ಡರ್ ಯಾವಾಗಲೂ ಸ್ಟಾಕ್‌ನ ಮೇಲ್ಭಾಗದಲ್ಲಿ ಉಳಿಯುತ್ತದೆ.
ಆದ್ದರಿಂದ, ನಾವು “../” ಅನ್ನು ಎದುರಿಸಿದಾಗಲೆಲ್ಲಾ, ನಾವು ಪ್ರಸ್ತುತ ಫೋಲ್ಡರ್‌ನಿಂದ ಹೊರಬರಬೇಕು (ಅಂದರೆ ಪೋಷಕ ಫೋಲ್ಡರ್‌ಗೆ ಸರಿಸಿ), ನಂತರ ನಾವು ಪ್ರಸ್ತುತ ಫೋಲ್ಡರ್ ಮೂಲವಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತೇವೆ. ಇಲ್ಲದಿದ್ದರೆ, ನಾವು ಮೇಲಿನ ಅಂಶವನ್ನು ಸ್ಟ್ಯಾಕ್‌ನಿಂದ ಪಾಪ್ ಮಾಡುತ್ತೇವೆ.
ಮತ್ತು ನಾವು “./” ಅನ್ನು ಎದುರಿಸಿದಾಗಲೆಲ್ಲಾ ನಾವು ಏನನ್ನೂ ಮಾಡಬೇಕಾಗಿಲ್ಲ.
ಈ ಮೂರು ಪ್ರಕರಣಗಳನ್ನು ನಾವು ಏಣಿಯಿದ್ದರೆ ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಬಳಸುತ್ತಿದ್ದೇವೆ.

ನಾವು ಇಲ್ಲಿ ತಿಳಿದುಕೊಳ್ಳಬೇಕಾದ ಒಂದು ವಿಷಯವೆಂದರೆ ಸ್ಟಾಕ್‌ನಲ್ಲಿರುವ ಅಂಶಗಳ ಸಂಖ್ಯೆಯು ನಾವು ಪ್ರಸ್ತುತ ಯಾವ ಆಳದಲ್ಲಿ ರೂಟ್ ಫೋಲ್ಡರ್‌ನಿಂದ ಬಂದಿದ್ದೇವೆ ಎಂದು ಹೇಳುತ್ತಿದೆ.
ಹೀಗಾಗಿ, ನಾವು ಕೊನೆಯಲ್ಲಿ ಸ್ಟಾಕ್ ಗಾತ್ರವನ್ನು ಅಂದರೆ ರೂಟ್ ಫೋಲ್ಡರ್‌ನಿಂದ ಹಿಂತಿರುಗಿಸುತ್ತೇವೆ.

ಕ್ರಾಲರ್ ಲಾಗ್ ಫೋಲ್ಡರ್ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರಕ್ಕಾಗಿ ಅನುಷ್ಠಾನ

ಸಿ ++ ಪ್ರೋಗ್ರಾಂ

#include <iostream>
#include <stack>
#include <vector>
using namespace std;
int minOperations(vector<string>& logs) {
        stack<string>stack;
        for(string log:logs){
            if(log=="../"){
                if(stack.size()>0)stack.pop();
            }
            else if(log=="./");
            else{
                stack.push(log);
            }
        }
        return stack.size();
    }
int main()
{
    vector<string>logs{"d1/","d2/","../","d21/","./"};
    cout<<minOperations(logs);
}
2

ಜಾವಾ ಪ್ರೋಗ್ರಾಂ

import java.util.*;
import java.lang.*;

class Solution
{  
    public static int minOperations(String[] logs) {
        Stack<String>stack=new Stack<String>();
        for(String log:logs){
            if(log.equals("../")){
                if(stack.size()>0)stack.pop();
            }
            else if(log.equals("./"));
            else{
                stack.push(log);
            }
        }
        return stack.size();
    }
    
    public static void main(String args[])
    {
        String[]logs={"d1/","d2/","../","d21/","./"};
        
        System.out.println(minOperations(logs));
    }
}
2

ಕ್ರಾಲರ್ ಲಾಗ್ ಫೋಲ್ಡರ್ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರಕ್ಕಾಗಿ ಸಂಕೀರ್ಣತೆ ವಿಶ್ಲೇಷಣೆ

ಸಮಯ ಸಂಕೀರ್ಣತೆ

ಒ (ಎನ್): ನಾವು ಕೊಟ್ಟಿರುವ ತಂತಿಗಳ ರೇಖೆಯನ್ನು ರೇಖಾತ್ಮಕವಾಗಿ ಹಾದುಹೋಗುತ್ತಿದ್ದೇವೆ ಮತ್ತು ಪ್ರತಿ ಪುನರಾವರ್ತನೆಯಲ್ಲೂ O (1) ಸಮಯದಲ್ಲಿ ಸ್ಟಾಕ್ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಮಾಡುತ್ತಿದ್ದೇವೆ. ಆದ್ದರಿಂದ, ಸಮಯದ ಸಂಕೀರ್ಣತೆಯು O (n) ಆಗಿದೆ, ಇಲ್ಲಿ n ಎಂಬುದು ಇನ್ಪುಟ್ ರಚನೆಯ ಉದ್ದವಾಗಿದೆ.

ಬಾಹ್ಯಾಕಾಶ ಸಂಕೀರ್ಣತೆ 

ಒ (ಎನ್): ಕೊಟ್ಟಿರುವ ಇನ್‌ಪುಟ್ ಅರೇ ಉದ್ದಕ್ಕೆ ಸಮನಾಗಿರಬಹುದಾದ ಸ್ಟಾಕ್ ಅನ್ನು ನಾವು ಬಳಸಿದ್ದೇವೆ. ಹೀಗಾಗಿ, ಕೆಟ್ಟ ಸ್ಥಳಾವಕಾಶದ ಸಂಕೀರ್ಣತೆಯು ಒ (ಎನ್) ಆಗಿದೆ.

ಅಪ್ರೋಚ್ 2 (ಆಳ ವೇರಿಯಬಲ್ ಬಳಸಿ)

ಡೆಪ್ತ್ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುವುದರ ಮೂಲಕ ಸಮಸ್ಯೆಯನ್ನು ಸುಲಭವಾಗಿ ಪರಿಹರಿಸಬಹುದು, ಅದು ಮೂಲತಃ ನಾವು ರೂಟ್ ಫೋಲ್ಡರ್‌ನಿಂದ ಯಾವ ಆಳದಲ್ಲಿದ್ದೇವೆ ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ.
ಪ್ರತಿ ಬಾರಿಯೂ ನಾವು ಮಕ್ಕಳ ಫೋಲ್ಡರ್‌ಗೆ ಹೋಗುವಾಗ, ನಾವು ಮೂಲ ಫೋಲ್ಡರ್‌ನಿಂದ ದೂರ 1 ಕ್ಕೆ ಹೋಗುತ್ತಿದ್ದೇವೆ. (ಅಂದರೆ ಆಳ ++)
ಪ್ರತಿ ಬಾರಿ ನಾವು ಪೋಷಕ ಫೋಲ್ಡರ್‌ಗೆ ಹೋಗುವಾಗ, ದೂರ 1 ರ ಮೂಲಕ ರೂಟ್ ಫೋಲ್ಡರ್‌ಗೆ ಹತ್ತಿರವಾಗುವುದನ್ನು ನಾವು ಕಡಿಮೆ ಮಾಡುತ್ತಿದ್ದೇವೆ. (ಅಂದರೆ ಆಳ–).
ನಾವು ರೂಟ್ ಫೋಲ್ಡರ್‌ನಲ್ಲಿಲ್ಲದಿದ್ದರೆ ಮಾತ್ರ ನಾವು ಮೂಲ ಫೋಲ್ಡರ್‌ಗೆ ಹೋಗಬಹುದು ಎಂಬುದನ್ನು ಗಮನಿಸಿ.
ಆದ್ದರಿಂದ, ನಾವು ಆಜ್ಞೆಗಳನ್ನು ಎಡದಿಂದ ಬಲಕ್ಕೆ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ ಲೂಪ್ .

  • ನಾವು “../” ಅನ್ನು ಎದುರಿಸಿದರೆ ನಾವು ರೂಟ್ ಫೋಲ್ಡರ್‌ನಲ್ಲಿದ್ದೇವೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತೇವೆ. ಇಲ್ಲದಿದ್ದರೆ ನಾವು ಆಳವನ್ನು 1 ರಷ್ಟು ಕಡಿಮೆ ಮಾಡುತ್ತೇವೆ.
  • ನಾವು "./" ಅನ್ನು ಎದುರಿಸಿದರೆ ನಾವು ಪ್ರಸ್ತುತ ಫೋಲ್ಡರ್ನಲ್ಲಿ ಉಳಿಯಬೇಕಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಆಳ ವೇರಿಯೇಬಲ್ನಲ್ಲಿ ಯಾವುದೇ ಬದಲಾವಣೆ ಇಲ್ಲ.
  • ಇಲ್ಲದಿದ್ದರೆ ನಾವು ನಮ್ಮ ಮಕ್ಕಳ ಫೋಲ್ಡರ್‌ಗೆ ಹೋಗಬೇಕಾಗುತ್ತದೆ. ಹೀಗಾಗಿ, ನಾವು ನಮ್ಮ ಆಳವನ್ನು 1 ರಷ್ಟು ಹೆಚ್ಚಿಸುತ್ತೇವೆ.

ಎಲ್ಲಾ ಆಜ್ಞೆಗಳ ನಂತರ, ನಮ್ಮ ಆಳ ವೇರಿಯಬಲ್ ರೂಟ್ ಫೋಲ್ಡರ್‌ನಿಂದ ದೂರವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತಿದೆ. ನಾವು ಅದನ್ನು .ಟ್‌ಪುಟ್‌ನಂತೆ ಹಿಂದಿರುಗಿಸುತ್ತೇವೆ.

ಕ್ರಾಲರ್ ಲಾಗ್ ಫೋಲ್ಡರ್ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರಕ್ಕಾಗಿ ಅನುಷ್ಠಾನ

ಸಿ ++ ಪ್ರೋಗ್ರಾಂ

#include <iostream>
#include <vector>
using namespace std;

int minOperations(vector<string>& logs)
{
    int depth=0;
    for(string log:logs)
    {
        if(log=="../")
        {
            if(depth>0)depth--;//moving to parent folder only if depth>0 i.e. current folder is    
                                 other than main folder 
        }
        else if(log=="./");    //staying to current folder
        else depth++;          //moving to child folder
    }
    return depth;
}
int main()
{
    vector<string>logs{"d1/","d2/","../","d21/","./"};
    cout<<minOperations(logs);
}
2

ಕ್ರಾಲರ್ ಲಾಗ್ ಫೋಲ್ಡರ್ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರಕ್ಕಾಗಿ ಜಾವಾ ಪ್ರೋಗ್ರಾಂ

import java.util.*;
import java.lang.*;

class Solution
{  
    public static int minOperations(String[] logs)
    {
        int depth=0;
        for(String log:logs)
        {
            if(log.equals("../"))
            {
                if(depth>0)depth--;//moving to parent folder only if depth>0 i.e. current folder is other than main folder 
            }
            else if(log.equals("./"));  //staying to current folder
            else depth++;               //moving to child folder
        }
        return depth;
    }
    
    public static void main(String args[])
    {
        String[]logs={"d1/","d2/","../","d21/","./"};
        
        System.out.println(minOperations(logs));
    }
}
2

ಕ್ರಾಲರ್ ಲಾಗ್ ಫೋಲ್ಡರ್ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರಕ್ಕಾಗಿ ಸಂಕೀರ್ಣತೆ ವಿಶ್ಲೇಷಣೆ

ಸಮಯ ಸಂಕೀರ್ಣತೆ

ಒ (ಎನ್): ನಾವು ಎಲ್ಲಾ ಆಜ್ಞೆಗಳನ್ನು ಒಮ್ಮೆ ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತಿದ್ದೇವೆ. ಹೀಗಾಗಿ, ಸಮಯದ ಸಂಕೀರ್ಣತೆಯು O (n) ಆಗಿದೆ.

ಬಾಹ್ಯಾಕಾಶ ಸಂಕೀರ್ಣತೆ 

ಒ (1): ನಾವು ಇದೀಗ ಡೆಪ್ತ್ ವೇರಿಯಬಲ್ ಅನ್ನು ಬಳಸಿದ್ದೇವೆ. ಹೀಗಾಗಿ, ಬಾಹ್ಯಾಕಾಶ ಸಂಕೀರ್ಣತೆಯು ಒ (1) ಆಗಿದೆ.