सी ++ में समूह स्थानांतरित स्ट्रिंग्स

मान लीजिए कि हमारे पास एक स्ट्रिंग है, हम उसके प्रत्येक अक्षर को उसके क्रमिक अक्षर में "स्थानांतरित" कर सकते हैं, इसलिए:"abc" को "bcd" में बदला जा सकता है। हम इस ऑपरेशन को करते रह सकते हैं जो अनुक्रम बनाता है:"abc" -> "bcd" -> ... -> "xyz"। यदि हमारे पास गैर-रिक्त स्ट्रिंग्स की एक सूची है जिसमें केवल लोअरकेस अक्षर हैं, तो हमें उन सभी स्ट्रिंग्स को समूहित करना होगा जो समान स्थानांतरण अनुक्रम से संबंधित हैं।

इसलिए, यदि इनपुट ["abc", "bcd", "acef", "xyz", "az", "ba", "a", "z"] जैसा है, तो आउटपुट [["abc] होगा। ","bcd",,"xyz"], ["az",,"ba"], ["acef"], ["a",,"z"] ]

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

• एक नक्शा परिभाषित करें मी

• एक 2डी सरणी रेट परिभाषित करें

• इनिशियलाइज़ करने के लिए i :=0, जब i <स्ट्रिंग्स का आकार, अपडेट (i से 1 तक बढ़ाएँ), करें -

  • कुंजी :=रिक्त स्ट्रिंग

  • इनिशियलाइज़ j :=1 के लिए, जब j <स्ट्रिंग्स का आकार [i], अपडेट करें (1 से j बढ़ाएँ), करें -

    • अंतर:=तार [i, j] - तार [i, j - 1]

    • यदि अंतर <0 है, तो -

      • अंतर :=अंतर + 26

    • key :=key concatenate "#" concatenate diff string के रूप में

  • m[key]

    . के अंत में तार [i] डालें

• m में प्रत्येक तत्व के लिए, −

  . करें

  • रिट के अंत में इसका मूल्य डालें

  • (इसे 1 से बढ़ाएं)

• वापसी रिट

उदाहरण

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

#include <bits/stdc++.h>
using namespace std;
void print_vector(vector<vector<auto< > v){
   cout << "[";
   for(int i = 0; i<v.size(); i++){
      cout << "[";
      for(int j = 0; j <v[i].size(); j++){
         cout << v[i][j] << ", ";
      }
      cout << "],";
   }
   cout << "]"<<endl;
}
class Solution {
public:
   vector<vector<string>> groupStrings(vector<string<& strings) {
      unordered_map<string, vector<string> > m;
      vector<vector<string< > ret;
      for (int i = 0; i < strings.size(); i++) {
         string key = "";
         for (int j = 1; j < strings[i].size(); j++) {
            int diff = strings[i][j] - strings[i][j - 1];
            if (diff < 0)
            diff += 26;
            key += "#" + to_string(diff);
         }
         m[key].push_back(strings[i]);
      }
      unordered_map<string, vector<string< >::iterator it = m.begin();
      while (it != m.end()) {
         ret.push_back(it->second);
         it++;
      }
      return ret;
   }
};
main(){
   Solution ob;
   vector<string< v = {"abc","bcd","acef","xyz","az","ba","a","z"};
   print_vector(ob.groupStrings(v));
}

इनपुट

{"abc","bcd","acef","xyz","az","ba","a","z"}

आउटपुट

[[az, ba, ],[a, z, ],[abc, bcd, xyz, ],[acef, ],]