ප්‍රකාශනයක දී ලබා දී ඇති විවෘත වරහනක් සඳහා සංවෘත වරහන දර්ශකය සොයා ගන්න


දුෂ්කරතා මට්ටම පහසු
නිතර අසනු ලැබේ ඇෙබෝ ඇමේසන් ෆ්ලිප්කාර්ට් ඔරකල් OYO කාමර Snapdeal වෝල්මාර්ට් ලැබ් යත්රා
අරා අඩුක්කුව String

ගැටළු ප්රකාශය

පේළියකි s දිග / ප්‍රමාණය n සහ ආරම්භක වර්ග වරහනක දර්ශකය නිරූපණය කරන පූර්ණ සංඛ්‍යාවක්. ප්‍රකාශනයක දී ලබා දී ඇති ආරම්භක වරහන සඳහා සංවෘත වරහන දර්ශකය සොයා ගන්න.

ප්‍රකාශනයක දී ලබා දී ඇති විවෘත වරහනක් සඳහා සංවෘත වරහන දර්ශකය සොයා ගන්න

උදාහරණයක්

s = "[ABC[23]][89]"

index = 0
8
s = "[C-[D]]"

index = 3
5
s = "E-[FX]]"

index = 0
-1

ප්රවේශය

පාවිච්චි කරන්න අඩුයි දත්ත ව්‍යුහය නිඛිල දී ඇති නූලෙහි ආරම්භක වරහන් වල දර්ශකය ගබඩා කිරීමට ටයිප් කරන්න. දී ඇති දේ හරහා නැවත ආරම්භ කිරීම ආරම්භ කරන්න පේළියකි දී ඇති දර්ශකයෙන් ආරම්භ වේ. ආරම්භක වරහනක් හමු වුවහොත් එය තොගයේ තල්ලු කරන්න. හමු වන සෑම සංවෘත වරහනක් සඳහාම තොගයේ සිට ආරම්භක වරහනක් සාදන්න. තොගය හිස් වුවහොත්, යම් දර්ශකයක තොගයේ ප්‍රමාණය 0 නම්, දර්ශකය මුද්‍රණය කරන්න. වෙනත් මුද්‍රණය -1.

ඇල්ගොරිතම

  1. දිග / ප්‍රමාණයේ නූලක් ආරම්භ කරන්න n සහ ආරම්භක වර්ග වරහනක දර්ශකය නිරූපණය කරන පූර්ණ සංඛ්‍යාවක්.
  2. ලබා දී ඇති ආරම්භක වරහන සඳහා සංවෘත වරහනෙහි දර්ශකයක් සොයා ගැනීම සඳහා ශ්‍රිතය සාදන්න, එමඟින් ප්‍රකාශනය නියෝජනය කරන නූල් අගයක් සහ පරාමිතියක් ලෙස දී ඇති නූලෙහි ආරම්භක වරහනක දර්ශකය නිරූපණය කරන පූර්ණ සංඛ්‍යා අගයක් පිළිගනී.
  3. දී ඇති දර්ශකයේ ඇති අක්‍ෂරය ආරම්භක වරහනකට සමාන නොවේදැයි පරීක්ෂා කරන්න, එනම් '[', මුද්‍රණය -1, සහ ආපසු.
  4. ඉන්පසු ලබා දී ඇති නූලෙහි වරහන් විවෘත කිරීමේ දර්ශකය ගබඩා කිරීම සඳහා පූර්ණ සංඛ්‍යා වර්ගයේ දත්ත ව්‍යුහයක් සාදන්න.
  5. දී ඇති දර්ශකයේ සිට ලබා දී ඇති නූල හරහා ගමන් කර නූල් වල වත්මන් දර්ශකයේ අක්‍ෂරය ආරම්භක වරහනකට සමාන දැයි පරීක්ෂා කරන්න, අට්ටාලයේ ඇති නූල් වල වත්මන් දර්ශකයේ අක්‍ෂරය තල්ලු කරන්න / ඇතුල් කරන්න.
  6. වෙනත් නම්, නූල් වල වත්මන් දර්ශකයේ අක්‍ෂරය සංවෘත වරහනකට සමාන නම්, එනම් ']', තොගයේ ඉහළින් ඇති මූලද්‍රව්‍යය පොප් / ඉවත් කරන්න. ඊට පසු, තොගය හිස් දැයි පරීක්ෂා කරන්න, එනම් තොගයේ ප්‍රමාණය 0 ට සමානද, වත්මන් දර්ශකය මුද්‍රණය කර ආපසු යන්න.
  7. මුද්‍රණය -1.

කේතය

C ++ වැඩසටහන වරහන විවෘත කිරීම සඳහා අනුරූප වසා දැමීමේ වරහන සොයා ගැනීමට

#include <bits/stdc++.h> 
using namespace std; 
  
void test(string expression, int index){ 
    int i; 
      
    if(expression[index]!='['){ 
        cout << "-1\n"; 
        return; 
    } 
      
    stack <int> st; 
      
    for(i = index; i < expression.length(); i++){ 
          
        if(expression[i] == '['){ 
            st.push(expression[i]);
        }
          
        else if(expression[i] == ']'){ 
            st.pop(); 
            if(st.empty()){ 
                cout << i << "\n"; 
                return; 
            } 
        } 
    } 
      
    cout << "-1\n"; 
} 
  
int main() { 
    string s = "[ABC[23]][89]";
    int index = 0;
    
    test(s, index); 
    
    return 0; 
}
8

විවෘත වරහන සඳහා අනුරූප වසා දැමීමේ වරහන සොයා ගැනීමට ජාවා වැඩසටහන

import java.util.Stack; 

class FindIndex{ 
  
    static void test(String expression, int index){ 
        int i; 
  
        if(expression.charAt(index) != '['){ 
            System.out.print("-1\n"); 
            return; 
        } 
  
        Stack<Integer> st = new Stack<>(); 
  
        for(i = index; i < expression.length(); i++){ 
  
            if(expression.charAt(i) == '['){ 
                st.push((int) expression.charAt(i)); 
            } 
            
            else if(expression.charAt(i) == ']'){ 
                st.pop(); 
                if(st.empty()){ 
                    System.out.print( i ); 
                    return; 
                } 
            } 
        } 
  
        System.out.print("-1\n"); 
    } 
  
    public static void main(String[] args){
        String s = "[ABC[23]][89]";
        int index = 0;
        
        test(s, index); 
    } 
}
8

සංකීර්ණ විශ්ලේෂණය

කාල සංකීර්ණත්වය

O (n) මෙහි n යනු දී ඇති නූල් වල දිග වේ. අපි නූල් වල ඇති සියලුම අක්ෂර හරහා ගමන් කර ඇති බැවින්, කාල සංකීර්ණතාව රේඛීය වේ.

අභ්‍යවකාශ සංකීර්ණතාව

O (n) දී ඇති නූලෙහි අක්ෂර ගබඩා කිරීමට අපි අවකාශය භාවිතා කළ බැවිනි. අවකාශයේ සංකීර්ණත්වය වරහන් ගණන මත රඳා පවතී. නමුත් නරකම අවස්ථාවෙහිදී, සියලුම අක්ෂර වර්ග වරහන් විය හැකිය. මේ අනුව අවකාශයේ සංකීර්ණතාව ද රේඛීය වේ.

ආශ්රිත