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

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

मान लीजिए कि हमारे पास एक स्ट्रिंग है, हम उसके प्रत्येक अक्षर को उसके क्रमिक अक्षर में "स्थानांतरित" कर सकते हैं, इसलिए:"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, ],]

  1. सी++ में केस-असंवेदनशील स्ट्रिंग तुलना

    सी ++ में हमारे पास मानक पुस्तकालय में तार हैं। इस कार्यक्रम में हम देखेंगे कि कैसे जांचा जाता है कि दो तार समान हैं या नहीं। इस मामले में हम मामले को नज़रअंदाज़ कर देंगे। यहाँ तर्क सरल है। हम पूरे स्ट्रिंग को लोअरकेस या अपरकेस स्ट्रिंग्स में बदल देंगे, फिर उनकी तुलना करेंगे, और परिणाम वापस करेंगे।

  1. सी ++ प्रोग्राम स्ट्रिंग्स कॉपी करने के लिए

    एक स्ट्रिंग एक आयामी वर्ण सरणी है जिसे एक शून्य वर्ण द्वारा समाप्त किया जाता है। एक स्ट्रिंग के मान को दूसरी स्ट्रिंग में कॉपी किया जा सकता है। यह या तो strcpy() फ़ंक्शन का उपयोग करके किया जा सकता है जो एक मानक लाइब्रेरी फ़ंक्शन है या इसके बिना। strcpy() फ़ंक्शन का उपयोग किए बिना एक स्ट्रिंग को कॉप

  1. सी ++ में स्ट्रिंग्स गुणा करें

    मान लीजिए कि हमारे पास एक स्ट्रिंग के रूप में दो संख्याएं हैं। हमें उन्हें गुणा करना है और परिणाम को भी एक स्ट्रिंग में वापस करना है। इसलिए यदि संख्याएं 26 और 12 हैं, तो परिणाम 312 होगा इसे हल करने के लिए, हम इन चरणों का पालन करेंगे - दो तर्क x और y लेते हुए यह इंगित करता है कि x, y को विभाजित करता