सी++ में कैमलकेस मिलान

मान लीजिए कि हमारे पास प्रश्नों की एक सूची है, और एक पैटर्न है, हमें एक उत्तर वापस करना होगा जो बूलियन की सूची होगी, जहां उत्तर [i] सत्य है और केवल अगर प्रश्न [i] पैटर्न से मेल खाता है। एक क्वेरी शब्द किसी दिए गए पैटर्न से मेल खाता है जब हम पैटर्न शब्द में लोअरकेस अक्षरों को सम्मिलित कर सकते हैं ताकि यह क्वेरी के बराबर हो।

तो अगर इनपुट ["फूबार", "फूबारटेस्ट", "फुटबॉल", "फ्रेमबफर", "फोर्सफीडबैक"] और पैटर्न ="एफबी" जैसा है, तो परिणाम [सत्य, झूठा, सच, झूठा, झूठा] होगा ।

इसे हल करने के लिए, हम इन चरणों का पालन करेंगे -

• इंसर्टनोड () नामक एक विधि को परिभाषित करें, यह सिर और स्ट्रिंग को लेता है

• वक्र:=सिर

• मैं के लिए 0 से लेकर s - 1 के आकार तक के लिए

  • एक्स:=एस [i]

  • अगर बच्चे [x] का curr शून्य नहीं है, तो बच्चे [x] का curr :=new node

  • curr :=बच्चे [x] करी के

• सेट isEnd of curr :=true

• मुख्य विधि से, निम्न कार्य करें -

• सिर:=नया नोड, सिर में पैटर्न डालें, एन:=क्वेरी सरणी का आकार, एम:=अस्थायी का आकार, ठीक:=सच

• j के लिए 0 से m - 1 की सीमा में

  • एक्स:=अस्थायी [जे]

  • अगर बच्चा [x] करी है, तो curr :=बच्चा [x] curr

  • अन्यथा जब अस्थायी [जे] ए से जेड तक की सीमा में है, तो ठीक है:=झूठा और लूप से तोड़ें

  • ans[i] :=isEnd of curr और OK

• वापसी उत्तर

उदाहरण(C++)

आइए एक बेहतर समझ प्राप्त करने के लिए निम्नलिखित कार्यान्वयन देखें -

#include <bits/stdc++.h>
using namespace std;
void print_vector(vector<auto> v){
   cout << "[";
   for(int i = 0; i<v.size(); i++){
      cout << v[i] << ", ";
   }
   cout << "]"<<endl;
}
struct Node{
   bool isEnd;
   map <char, Node*> child;
   Node(){
      isEnd = false;
   }
};
class Solution {
   public:
   void insertNode(Node* head, string s){
      Node* curr = head;
      for(int i = 0; i < s.size(); i++){
         char x = s[i];
         if(!curr->child[x]){
            curr->child[x] = new Node();
         }
         curr = curr->child[x];
      }
      curr->isEnd = true;
   }
   vector<bool> camelMatch(vector<string>& queries, string pattern){
      Node* head = new Node();
      insertNode(head, pattern);
      int n = queries.size();
      vector <bool> ans(n);
      Node* curr;
      bool ok;
      for(int i = 0; i < n; i++){
         string temp = queries[i];
         curr = head;
         int m = temp.size();
         ok = true;
         for(int j = 0; j < m; j++){
            char x = temp[j];
            if(curr->child[x]){
               curr = curr->child[x];
            }
            else if(temp[j] >= 'A' && temp[j] <= 'Z'){
               ok = false;
               break;
            }
         }
         ans[i] = curr->isEnd && ok;
      }
      return ans;
   }
};
main(){
   vector<string> v1 = {"FooBar","FooBarTest","FootBall","FrameBuffer","ForceFeedBack"};
   Solution ob;
   print_vector(ob.camelMatch(v1, "FB"));
}

इनपुट

["FooBar","FooBarTest","FootBall","FrameBuffer","ForceFeedBack"]
"FB"

आउटपुट

[1, 0, 1, 1, 0, ]