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


कठिनाई तह मध्यम
बारम्बार सोधिन्छ अमेजन फेसबुक गुगल माइक्रोसफ्ट
ह्याशिंग घागो

हामीले दिइएका शब्दहरूको समूह anagram फेला पार्नु पर्छ। यसको मतलब प्रत्येक शब्दको लागि हामी जाँदै छौं भाग्य यो र यसलाई एक कुञ्जी र मूल इनपुटको रूपमा भण्डार गर्नुहोस् जुन मानको रूपमा क्रमबद्ध गरिएको छैन र यदि कुनै अन्य इनपुटसँग पहिलेको क्रमबद्ध स्ट्रि asको समान मान छ भने हामी समान कुञ्जीमा भण्डार गर्न गइरहेका छौं, तर भिन्न मानको साथ, यसको लागि, भेक्टर आउट आउटमेन्टमा एक आर्गुमेन्टका रूपमा पारित गरियो जसमा हामी सबै अपरेसनहरू गर्ने छौं।

अनाग्रामहरू: अर्को शब्दका सबै अक्षरहरूलाई पुन: संगठित गरेर सिर्जना गरिएका शब्दहरू एनाग्रामको रूपमा चिनिन्छन्।

उदाहरण: खान, खान, चिया एक अर्काको anagram हो

यस समस्यामा तपाईलाई केहि शब्दहरू दिइन्छ। तपाईको कार्य भनेको ती शब्दहरुलाई समुहमा मिलाउनु हो जुन एक अर्काको आनाग्राम हो।

उदाहरणका

इनपुट: खान, चिया, टेन, खाए, नाट, ब्याट

उत्पादन: [खान, चिया, खाए], [ट्यान, नाट], [ब्याट]

अल्गोरिदम

  1. मानचित्र चर म्याम्याप, भेक्टर घोषणा गर्नुहोस् > चर अन्तिम_सेट।
  2. एक लूप भित्र, इनपुट मान कुञ्जीमा लिनुहोस् र तिनीहरूलाई क्रमबद्ध गर्नुहोस्
  3. इनपुटको मान पछाडि थिच्नुहोस् [i] नक्साको कुञ्जीमा (जुन क्रमबद्ध गरिएको स्ट्रिंग हो)।
  4. प्रत्येक पुशब्याकको लागि अन्तिम सेटमा मान प्रयोग गर्दै।
  5. अन्तिम सेट प्रिन्ट गर्नुहोस्।

स्पष्टीकरण

सुरुमा, हाम्रो इनपुट सेट जसमा हाम्रो सबै इनपुट मानहरू प्यारामिटरको रूपमा पास गरिएको छ। यहाँ हामी नक्शा घोषित गर्छौं र सदिश भेक्टर्स को क्रमशः my_map र final_set का चर। लूपमा आउँदैछ जुन भेक्टरको पुनरावृत्ति गर्दछ जब सम्म भेक्टरको आकार नपुगेसम्म। यस लूपमा, हामी कुञ्जीमा इनपुटको प्रत्येक अनुक्रमणिकाको मान लिनेछौं।

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

त्यसोभए हामी भेन्टर्सको अन्तिम सेट भेक्टरमा माई_म्यापका सबै मानहरू थप्न जाँदैछौं। र अन्तमा, यो प्रिन्ट गर्नुहोस्।

उदाहरणका

मान्नुहोस् इनपुट: [खान, चिया, टेन, खाए, नट, ब्याट]

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

Aet को लागि कुञ्जीको रूपमा खानाहरू मानको रूपमा भण्डार हुँदैछ

फेरि, चियाको क्रमबद्ध कुञ्जी aet कुञ्जीको रूपमा भण्डार गर्न गइरहेको छ र चियाको रूपमा मान।

सबै पुनरावृत्ति गरे पछि:

एट (क्रमबद्ध स्ट्रि)): [खान, चिया, अटे] // कुञ्जी-मान जोडी

कमिला (क्रमबद्ध स्ट्रिंग): [ट्यान, कमिला] // कुञ्जी-मान जोडी

abt (क्रमबद्ध स्ट्रिंग): [bat] // कुञ्जी-मान जोडी

र अन्त्यमा, हामी आउटपुट पाउँछौं।

कार्यान्वयन

समूह अनाग्रामहरूको लागि 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 ]
]

समूह Anagram को लागी जावा कार्यक्रम

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 प्रत्येक शब्दको अधिकतम वर्ण हो।