समूह एनाग्राम


कठिनाई स्तर मध्यम
में अक्सर पूछा वीरांगना Facebook गूगल माइक्रोसॉफ्ट
hashing तार

हमें दिए गए शब्दों के समूह आरेखों का पता लगाना होगा। इसका मतलब है कि हम जिस एक शब्द के लिए जा रहे हैं तरह इसे एक कुंजी और मूल इनपुट के रूप में संग्रहित करें जिसे मान के रूप में क्रमबद्ध नहीं किया गया है और यदि किसी अन्य इनपुट का मूल्य पहले की तरह स्ट्रिंग के समान है जिसे हम एक ही कुंजी में संग्रहीत करने जा रहे हैं, लेकिन इसके लिए अलग मूल्य वेक्टर को एक फ़ंक्शन के रूप में पास किया जाता है जिसमें हम सभी ऑपरेशन करने जा रहे हैं।

अनाग्रामज़: वे शब्द जो किसी अन्य शब्द के सभी अक्षरों को पुन: व्यवस्थित करके बनाए जाते हैं, को विपर्यय के रूप में जाना जाता है।

उदाहरण: खाओ, खाओ, चाय एक दूसरे के अंग हैं

इस समस्या में, आपको कुछ शब्द दिए गए हैं। आपका काम उन शब्दों को एक समूह में व्यवस्थित करना है जो एक-दूसरे के प्रतिरूप हैं।

उदाहरण

इनपुट: खाओ, चाय, तन, खाया, नट, बल्ले

आउटपुट: [खाओ, चाय खाओ], [तन, नट], [बल्ले]

कलन विधि

  1. एक मानचित्र चर mymap, एक वेक्टर घोषित करें > चर अंतिम_सेट।
  2. एक लूप के अंदर, इनपुट मानों को कुंजी में लें और उन्हें सॉर्ट करें
  3. मानचित्र के कुंजी (जो] एक सॉर्ट किया गया इनपुट का मान वापस रखें।
  4. अंतिम सेट में प्रत्येक पुशबैक मान के लिए उपयोग करना।
  5. अंतिम सेट प्रिंट करें।

व्याख्या

सबसे पहले, हमारे इनपुट सेट जिसमें हमारे सभी इनपुट मान एक पैरामीटर के रूप में पारित हो जाते हैं। यहां हम एक नक्शा और घोषित करते हैं वेक्टर क्रमशः my_map और अंतिम_सेट के वैक्टर चर। लूप के लिए आ रहा है जो वेक्टर के आकार तक पहुंचने तक वेक्टर को पुनरावृत्त करता है। इस लूप में, हम इनपुट के प्रत्येक इंडेक्स का मान एक कुंजी में लेने जा रहे हैं।

कुंजी में मान स्टोर हम इसे क्रमबद्ध करने जा रहे हैं ताकि हम इसे एनाग्राम के रूप में जांच सकें, और इनपुट के मूल्य को [i] मानचित्र के एक प्रमुख स्थान पर रख दें जहां कुंजी एक क्रमबद्ध स्ट्रिंग है। यह तब तक चलेगा जब तक हम इनपुट सेट के सभी मूल्यों को पुनरावृत्त नहीं कर देते। और नक्शे में सभी प्रमुख मूल्य को संग्रहीत करना,

फिर हम my_map के सभी मानों को वैक्टर के अंतिम सेट वेक्टर में जोड़ने जा रहे हैं। और अंत में, इसे प्रिंट करें।

उदाहरण

मान लीजिए इनपुट: [खाओ, चाय, तन, खाया, नट, बल्ले]

क्रमबद्ध कुंजी = aet

चींटियों के लिए एक महत्वपूर्ण खाने के रूप में एक मूल्य के रूप में संग्रहीत किया जा रहा है

फिर से, चाय की सॉर्ट की गई चाबी एक और चाय के रूप में मूल्य के रूप में संग्रहीत करने जा रही है।

सभी पुनरावृत्तियों को करने के बाद:

aet (क्रमबद्ध स्ट्रिंग): [खाओ, चाय, खाओ] // कुंजी-मूल्य जोड़ी

ant (सॉर्ट किया गया स्ट्रिंग): [tan, ant] // की-वैल्यू पेयर

abt (क्रमबद्ध स्ट्रिंग): [बल्ले] // कुंजी-मूल्य जोड़ी

और आखिर में, हमें आउटपुट मिलता है।

कार्यान्वयन

ग्रुप एनाग्राम के लिए C ++ प्रोग्राम

#include<iostream>
#include<vector>
#include<unordered_map>
#include<algorithm>
using namespace std;

vector<vector<string> > groupAnagrams(vector<string>& input_set)
{
    // the first value will hold the key,
    //the second vector is used to hold the multiple values.
    unordered_map<string, vector<string>> my_map;
    vector<vector<string> > final_set;

    for (int i = 0; i < input_set.size(); i++)
    {
        // take value at the index as a key
        string key = input_set[i];

        //sort the key
        sort(key.begin(), key.end());

        // add the value to that key
        my_map[key].push_back(input_set[i]);

    }

    for (auto n : my_map)
    {
        // add all the values in the map to the final set
        final_set.push_back(n.second);
    }

    return final_set;
}

int main()
{
    vector<string> input_set;
    input_set.push_back("eat");
    input_set.push_back("tea");
    input_set.push_back("tan");
    input_set.push_back("ate");
    input_set.push_back("nat");
    input_set.push_back("bat");

    vector<vector<string> > final_set =  groupAnagrams(input_set);

    // print the output
    cout<<" [ "<<endl;
    for (int i = 0; i < final_set.size(); i++)
    {
        if (final_set[i].size() > 0)
        {
            cout << "  [";
            for (int j = 0; j < final_set[i].size(); j++)
                cout<< final_set[i][j]<<" ";
            cout << "]";
        }
        cout<<endl;
    }
    cout<<" ] ";

    return 0;
}
[
 [bat ]
 [tan nat ]
 [eat tea ate ]
]

ग्रुप एनाग्राम के लिए जावा प्रोग्राम

import java.util.*;
import java.util.stream.Collectors;

class findGroupAnagrams
{
  public static void getgroup(String[] words)
  {
    List<String> myList = Arrays.stream(words)
        .map(s -> s.toCharArray())
        .map(chars -> { Arrays.sort(chars); return new String(chars); })
        .collect(Collectors.toList());
    Map<String, List<Integer>> map = new HashMap<>();
    for (int i = 0; i < myList.size(); i++)
    {
      map.putIfAbsent(myList.get(i), new ArrayList<>());
      map.get(myList.get(i)).add(i);
    }
    for (var entry: map.entrySet()) {
      System.out.println(entry.getValue().stream()
              .map(index -> words[index])
              .collect(Collectors.toList()));
    }
  }
  public static void main(String[] args)
  {
    String[] input = {"eat","tea","tan","ate","nat","bat"};
    getgroup(input);
  }
}
[eat, tea, ate]
[bat]
[tan, nat]

समूह एनाग्राम के लिए जटिलता विश्लेषण

समय जटिलता

O (NM) जहाँ N शब्दों की संख्या है और M प्रत्येक शब्द का अधिकतम वर्ण है।

अंतरिक्ष जटिलता

O (N + M) जहाँ N शब्दों की संख्या है और M प्रत्येक शब्द का अधिकतम वर्ण है।