கிராலர் பதிவு கோப்புறை லீட்கோட் தீர்வு  


சிரமம் நிலை எளிதாக
அடிக்கடி கேட்கப்படுகிறது மெர்காரி
குறியீட்டு பேட்டி நேர்காணல் தயாரிப்பு லீட்கோட் LeetCodeSolutions ஸ்டேக்

சிக்கல் அறிக்கை  

இந்த சிக்கலில், ஒரு கோப்புறை அமைப்பில் எங்கள் நிலையை நாங்கள் தொடர்ந்து கண்காணித்து வருகிறோம். நாங்கள் ஆரம்பத்தில் ரூட் கோப்புறையிலோ அல்லது இந்த அமைப்பின் பிரதான கோப்புறையிலோ இருக்கிறோம்.
எங்களிடம் அடிப்படையில் 3 வகையான கட்டளைகள் உள்ளன. கட்டளைகள் சரம் வடிவத்தில் உள்ளன, அதில் ஒவ்வொரு சரம் ஒரு கட்டளையை குறிக்கிறது.

  •  “../” என்றால் தற்போதைய கோப்புறையின் பெற்றோர் கோப்புறைக்குச் செல்லுங்கள் (ஏற்கனவே ரூட் கோப்புறையில் இருந்தால் எங்கும் செல்ல வேண்டாம்).
  •  “./” தற்போதைய கோப்புறையில் இருங்கள்.
  •  “X /” தற்போதைய கோப்புறையின் குழந்தை கோப்புறையில் x பெயர் உள்ளது.

மேலே உள்ள 3 கட்டளைகளின் கலவையான கட்டளைகளின் வரிசை நமக்கு வழங்கப்படுகிறது. கொடுக்கப்பட்ட கட்டளைகளை முன்னரே வடிவமைத்த பின் ரூட் கோப்புறையில் செல்ல குறைந்தபட்ச செயல்பாட்டின் எண்ணிக்கையை நாம் கண்டுபிடிக்க வேண்டும்.
எ.கா.
logs = [“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 என்பது உள்ளீட்டு வரிசையின் நீளம்.

விண்வெளி சிக்கலானது 

ஓ (ந): கொடுக்கப்பட்ட உள்ளீட்டு வரிசை நீளத்திற்கு சமமாக இருக்கும் ஒரு அடுக்கை நாங்கள் பயன்படுத்தியுள்ளோம். எனவே, மிக மோசமான இட சிக்கலானது O (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): நாம் இப்போது ஒரு ஆழ மாறியைப் பயன்படுத்தினோம். எனவே, விண்வெளி சிக்கலானது O (1) ஆகும்.

1