Computer >> कंप्यूटर >  >> प्रोग्रामिंग >> C++

C++ में संयोजित शब्द

मान लीजिए हमारे पास शब्दों की एक सूची है। ये शब्द अलग हैं। हमें एक एल्गोरिथम तैयार करना होगा जो शब्दों की सूची में सभी सम्मिलित शब्दों को ढूंढेगा। एक संयोजित शब्द वास्तव में एक स्ट्रिंग है जिसमें दिए गए सरणी में कम से कम दो छोटे शब्द शामिल होते हैं।

तो अगर शब्द ["गाय", "गाय", "गाय का बकरा", "बकरी", "बकरी बकरी", "हिप्पोपोटामस", "हिरण", "डीरकोगोअटको"] जैसे हैं, तो आउटपुट ["गाय का बकरा" होगा, "बकरी का बकरा", "डीरकाउगोआटकाउ"]

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

  • एक फ़ंक्शन परिभाषित करें isPresent(), यह str, head, idx, एक सरणी dp,
  • लेगा
  • यदि idx>=str का आकार, तो −
    • सही लौटें
  • यदि dp[idx] -1 के बराबर नहीं है, तो −
    • रिटर्न डीपी[idx]
  • नोड कर्व बनाएं:=हेड
  • ठीक है:=झूठा
  • इनिशियलाइज़ i :=idx के लिए, जब i
  • x :=str[i]
  • अगर बच्चा नहीं है[x] करी है, तो −
    • लूप से बाहर आएं
  • अन्यथा
    • curr :=बच्चे[x] करी का
  • यदि isEnd of curr सत्य है, तो −
    • ठीक है:=ठीक है या मौजूद है(str, head, i + 1, dp)
  • रिटर्न डीपी[idx] :=ठीक है
  • एक फ़ंक्शन को परिभाषित करें insertNode(), यह सिर लेगा, s,
  • एक नोड बनाएं curr =head
  • इनिशियलाइज़ i :=0 के लिए, जब i
  • x :=s[i]
  • अगर बच्चा नहीं है[x] करी है, तो −
    • बच्चा[x] curr :=एक नया नोड बनाएं
  • curr :=बच्चे[x] करी का
  • कर का अंत है:=सच
  • मुख्य विधि से, निम्न कार्य करें -
  • सिर:=एक नया नोड बनाएं
  • शब्दों की लंबाई के आधार पर शब्दों को क्रमबद्ध करें
  • एक सरणी रिट परिभाषित करें
  • इनिशियलाइज़ i :=0 के लिए, जब i <शब्दों का आकार, अपडेट करें (i से 1 बढ़ाएँ), करें −
    • करी :=शब्द[i]
    • यदि curr "" के समान है, तो −
      • निम्न भाग पर ध्यान न दें, अगले भाग पर जाएं
    • कर्र के समान आकार की एक सरणी डीपी परिभाषित करें, इसे -1 से भरें
    • यदि फ़ंक्शन को कॉल करें isPresent(curr, head, 0, dp) गैर-शून्य है, तो −
      • रिट के अंत में curr डालें
    • अन्यथा
      • फ़ंक्शन को कॉल करें insertNode(head, curr)
  • रिटर्न रिटर्न
  • आइए बेहतर समझ पाने के लिए निम्नलिखित कार्यान्वयन देखें -

    उदाहरण

    #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:
       bool isPresent(string str, Node* head, int idx, vector <int>& dp){
          if(idx >= str.size())return true;
          if(dp[idx] != -1)return dp[idx];
          Node* curr = head;
          bool ok = false;
          for(int i = idx; i < str.size(); i++){
             char x = str[i];
             if(!curr->child[x]){
                break;
             }else{
                curr = curr->child[x];
             }
             if(curr->isEnd){
                ok |= isPresent(str, head, i + 1, dp);
             }
          }
          return dp[idx] = ok;
       }
       static bool cmp(string s1, string s2){
          return s1.size() < s2.size();
       }
       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<string> findAllConcatenatedWordsInADict(vector<string>& words) {
          Node* head = new Node();
          sort(words.begin(), words.end(), cmp);
          vector <string> ret;
          for(int i = 0; i < words.size(); i++){
             string curr = words[i];
             if(curr=="")continue;
             vector <int> dp(curr.size(), -1);
             if(isPresent(curr, head, 0, dp)){
                ret.push_back(curr);
             }else{
                insertNode(head, curr);
             }
          }
          return ret;
       }
    };
    main(){
       Solution ob;
       vector<string> v =    {"cow","cows","cowsgoatcows","goat","goatcowsgoat","hippopotamuses","deer","deercowgoatcow"};
       print_vector(ob.findAllConcatenatedWordsInADict(v));
    }

    इनपुट

    {"cow","cows","cowsgoatcows","goat","goatcowsgoat","hippopotamuses","deer","deercowgoatcow"}

    आउटपुट

    [cowsgoatcows, goatcowsgoat, deercowgoatcow, ]

    1. सी ++ में एक वाक्य में पैलिंड्रोम शब्दों की गणना करें

      हमें एक स्ट्रिंग दी गई है जिसमें एक अंग्रेजी वाक्य है। लक्ष्य स्ट्रिंग में शब्दों की संख्या का पता लगाना है जो पैलिंड्रोम हैं। पैलिंड्रोम शब्द वे होते हैं जिन्हें शुरू या अंत से पढ़ने पर वर्णमाला क्रम समान होता है। यदि वाक्य मैडम अच्छा मलयालम बोलती है है, तो पैलिंड्रोम शब्दों की संख्या 2 है। (मैडम औ

    1. सी++ में सबसे बड़ा बीएसटी सबट्री

      मान लीजिए हमारे पास एक बाइनरी ट्री है; हमें इसका सबसे बड़ा सबट्री ढूंढ़ना होगा जहां सबसे बड़ा मतलब सबट्री जिसमें सबसे बड़ी संख्या में नोड्स हों। तो, अगर इनपुट पसंद है, तो आउटपुट 3 होगा, क्योंकि इस मामले में सबसे बड़ा बीएसटी सबट्री हाइलाइट किया गया है। इसे हल करने के लिए, हम इन चरणों का पालन करे

    1. सी++ में एक स्ट्रिंग में सभी अजीब शब्दों को प्रिंट करें

      इस समस्या में हमें एक वाक्य दिया जाता है। हमारा काम वाक्य से सभी स्ट्रिंग्स को प्रिंट करना है जो कि मजेदार शब्द हैं। मजेदार शब्द एक शब्द है जो शर्त का पालन करता है - स्ट्रिंग के आसन्न वर्णों और इसके विपरीत स्ट्रिंग के बीच पूर्ण अंतर बराबर है। |string[0] - string[1]| = |revstring[0]-revstring[1]| आ