ક્રોલર લ Logગ ફોલ્ડર લિટકોડ સોલ્યુશન


મુશ્કેલી સ્તર સરળ
વારંવાર પૂછવામાં આવે છે મર્કરી
સ્ટેક

સમસ્યા નિવેદન

આ સમસ્યામાં, અમે ફોલ્ડર સિસ્ટમમાં અમારી સ્થિતિનો ટ્રેકિંગ રાખીએ છીએ. આપણે શરૂઆતમાં રૂટ ફોલ્ડર અથવા આ સિસ્ટમના મુખ્ય ફોલ્ડર પર છીએ.
આપણી પાસે અહીં મૂળભૂત રીતે 3 પ્રકારની આદેશો છે. આદેશો શબ્દમાળાના સ્વરૂપમાં હોય છે જેમાં દરેક શબ્દમાળાનો અર્થ આદેશ થાય છે.

  •  “../” નો અર્થ વર્તમાન ફોલ્ડરના પેરેંટલ ફોલ્ડર પર જાઓ (જો પહેલાથી રૂટ ફોલ્ડરમાં હોય તો ક્યાંય જશો નહીં).
  •  "./" વર્તમાન ફોલ્ડરમાં રહો.
  •  “X /” વર્તમાન ફોલ્ડરના ચાઇલ્ડ ફોલ્ડરમાં જાય છે જેમાં નામ છે x.

આપણને આદેશોનો ક્રમ અપાયો છે જે ઉપરના 3 આદેશોનું સંયોજન છે. આપેલ આદેશોને પ્રીફોર્મ કર્યા પછી રુટ ફોલ્ડરમાં પાછા જવા માટે આપણે ઓછામાં ઓછી ઓપરેશનની સંખ્યા શોધવા પડશે.
દા.ત.
લsગ્સ = ["ડી 1 /", "ડી 2 / খেলা, খেলা../", "ડી 21 / বাউটিং./"]

ક્રોલર લ Logગ ફોલ્ડર લિટકોડ સોલ્યુશન
આપણે રુટ ફોલ્ડરથી theંડાઈ 2 પર છીએ. તેથી, અમારો જવાબ 2 હશે.

ઉદાહરણ

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

સમજૂતી:

આ ફેરફાર ફોલ્ડર operationપરેશનનો ઉપયોગ “../” 2 વખત કરો અને મુખ્ય ફોલ્ડર પર પાછા જાઓ.

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

અભિગમ 1 (સ્ટેકનો ઉપયોગ કરીને)

આપણે ફાઇલ નામોનો સ્ટેક વાપરી શકીએ છીએ. શરૂઆતમાં અમારું સ્ટેક ખાલી છે. જ્યારે પણ આપણે સબફોલ્ડરમાં જવું હોય ત્યારે સબફોલ્ડરનું નામ સ્ટેકમાં ધકેલી દેવામાં આવે છે. આમ, આપણે હાલમાં જે ફોલ્ડરમાં છીએ તે હંમેશા સ્ટેકની ટોચ પર રહેશે.
તેથી, જ્યારે પણ આપણે "../" નો સામનો કરીએ છીએ, એટલે કે આપણે વર્તમાન ફોલ્ડરમાંથી બહાર આવવું પડશે (એટલે ​​કે પેરેંટલ ફોલ્ડરમાં ખસેડો), પછી આપણે તપાસ કરીશું કે વર્તમાન ફોલ્ડર રૂટ છે કે નહીં. જો ના, તો પછી આપણે સ્ટેકમાંથી ટોચનું તત્વ પ popપ કરીશું.
અને અલબત્ત જ્યારે પણ આપણે “./” નો સામનો કરીશું, આપણે કંઇ કરવાનું નથી.
જો સીડી હોય તો આપણે આ ત્રણ કેસનો ઉપયોગ કરી રહ્યા છીએ.

એક વસ્તુ આપણે અહીં જાણવી જોઈએ કે સ્ટેકમાં હાજર તત્વોની સંખ્યા કહી રહી છે કે આપણે હાલમાં રૂટ ફોલ્ડરમાંથી કેટલી .ંડાઈએ છીએ.
આમ, આપણે અંતમાં સ્ટેકનું કદ, એટલે કે રુટ ફોલ્ડરથી returnંડાઈ આપીશું.

ક્રાઉલર લ Logગ ફોલ્ડર લીટકોડ સોલ્યુશન માટે અમલીકરણ

સી ++ પ્રોગ્રામ

#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

ક્રાઉલર લ Logગ ફોલ્ડર લીટકોડ સોલ્યુશન માટે જટિલતા વિશ્લેષણ

સમય જટિલતા

ઓ (એન): અમે આપેલ શબ્દમાળાઓની એરેને અનુરૂપ રીતે પસાર કરી રહ્યા છીએ અને દરેક પુનરાવૃત્તિમાં O (1) સમય માં સ્ટેક operationપરેશન કરી રહ્યા છીએ. આમ, સમય જટિલતા ઓ (એન) છે, જ્યાં એન ઇનપુટ એરેની લંબાઈ છે.

અવકાશ જટિલતા 

ઓ (એન): અમે એક સ્ટેકનો ઉપયોગ કર્યો છે જેનું કદ આપેલ ઇનપુટ એરે લંબાઈ જેટલું હોઈ શકે. આમ, સૌથી ખરાબ કિસ્સામાં જગ્યાની જટિલતા ઓ (એન) છે.

અભિગમ 2 (depthંડાઈ ચલનો ઉપયોગ કરીને)

ફક્ત ંડાઈના ચલને ટ્ર keepક રાખતા રહીને સમસ્યા સરળતાથી હલ થઈ શકે છે જે મૂળ રૂપે બતાવે છે કે આપણે રૂટ ફોલ્ડરમાંથી કઈ depthંડાઈએ છીએ.
દરેક વખતે જ્યારે આપણે કોઈ ચિલ્ડ્રન ફોલ્ડર પર જઈએ છીએ, ત્યારે આપણે અંતર 1 દ્વારા રુટ ફોલ્ડરથી ઘણા દૂર જઈએ છીએ (એટલે ​​કે depthંડાઈ ++)
દરેક વખતે જ્યારે આપણે પેરેંટલ ફોલ્ડર પર જઈએ છીએ, ત્યારે આપણે અંતર 1 (એટલે ​​કે –ંડાઈ) દ્વારા રુટ ફોલ્ડરની નજીક આવતા જઈએ છીએ.
નોંધો કે આપણે ફક્ત પેરેંટલ ફોલ્ડરમાં જઇ શકીએ જો આપણે રૂટ ફોલ્ડરમાં ન હોઈએ.
તો, આપણે એક આદેશ માટે ડાબેથી જમણે આદેશો ચલાવવાનું શરૂ કરીશું લૂપ .

  • જો આપણે “../” નો સામનો કરીશું, તો આપણે તપાસ કરીશું કે આપણે રૂટ ફોલ્ડરમાં છીએ કે નહીં. જો નહીં તો આપણે 1 દ્વારા depthંડાઈ ઘટાડીશું.
  • બાકી જો આપણે “./” નો સામનો કરીશું, તો આપણે વર્તમાન ફોલ્ડરમાં રહેવું પડશે, આમ depthંડાઈના ચલમાં કોઈ ફેરફાર નહીં.
  • બાકી આપણે આપણા કોઈ ચિલ્ડ્રન ફોલ્ડરમાં જવું પડશે. આમ, આપણે આપણી depthંડાઈ 1 થી વધારીશું.

બધા આદેશો પછી, અમારું depthંડાઈ ચલ રુટ ફોલ્ડરથી અંતર સ્ટોર કરી રહ્યું છે. આપણે તેને આઉટપુટ તરીકે આપીશું.

ક્રાઉલર લ Logગ ફોલ્ડર લીટકોડ સોલ્યુશન માટે અમલીકરણ

સી ++ પ્રોગ્રામ

#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

ક્રાઉલર લ Logગ ફોલ્ડર લીટકોડ સોલ્યુશન માટે જાવા પ્રોગ્રામ

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

ક્રાઉલર લ Logગ ફોલ્ડર લીટકોડ સોલ્યુશન માટે જટિલતા વિશ્લેષણ

સમય જટિલતા

ઓ (એન): આપણે બધા આદેશો એકવાર એક્ઝેક્યુટ કરીશું. આમ, સમય જટિલતા ઓ (એન) છે.

અવકાશ જટિલતા 

ઓ (1): આપણે હમણાં જ એક .ંડાઈ ચલનો ઉપયોગ કર્યો છે. આમ, અવકાશ જટિલતા ઓ (1) છે.