గ్రూప్ అనాగ్రామ్స్


కఠినత స్థాయి మీడియం
తరచుగా అడుగుతుంది అమెజాన్ <span style="font-family: Mandali; ">ఫేస్‌బుక్ </span> గూగుల్ మైక్రోసాఫ్ట్
హ్యాషింగ్ స్ట్రింగ్

ఇచ్చిన పదాల సమూహ అనాగ్రామ్‌లను మనం కనుగొనాలి. దీని అర్థం మనం వెళ్లే ప్రతి పదానికి విధమైన దాన్ని విలువగా క్రమబద్ధీకరించని కీ మరియు అసలైన ఇన్‌పుట్‌గా నిల్వ చేయండి మరియు మరేదైనా ఇన్‌పుట్‌కు గతంలో క్రమబద్ధీకరించబడిన స్ట్రింగ్‌కు సమానమైన విలువ ఉంటే అదే కీ వద్ద నిల్వ చేయబోతున్నాం, కానీ వేరే విలువతో, దీని కోసం, a వెక్టర్ అవుట్ ఫంక్షన్ లోకి ఆర్గ్యుమెంట్ గా పంపబడుతుంది, దీనిలో మేము అన్ని ఆపరేషన్లు చేయబోతున్నాం.

అనగ్రామ్స్: మరొక పదం యొక్క అన్ని అక్షరాలను క్రమాన్ని మార్చడం ద్వారా సృష్టించబడిన పదాలను అనాగ్రామ్స్ అంటారు.

ఉదాహరణ: తినండి, తిన్నది, టీ అనేది ఒకదానికొకటి అనాగ్రాములు

ఈ సమస్యలో, మీకు కొన్ని పదాలు ఇవ్వబడ్డాయి. మీ పని ఏమిటంటే, ఆ పదాలను ఒకదానికొకటి అనాగ్రామ్‌లుగా ఉండే సమూహంలో అమర్చడం.

ఉదాహరణ

ఇన్పుట్: తినండి, టీ, టాన్, తిన్నది, నాట్, బ్యాట్

అవుట్పుట్: [తినండి, టీ, తిన్నారు], [తాన్, నాట్], [బ్యాట్]

అల్గారిథం

  1. మ్యాప్ వేరియబుల్ మైమాప్, వెక్టర్ అని ప్రకటించండి > వేరియబుల్ ఫైనల్_సెట్.
  2. లూప్ లోపల, కీలోని ఇన్పుట్ విలువలను తీసుకొని వాటిని క్రమబద్ధీకరించండి
  3. మ్యాప్ యొక్క కీకి (ఇది క్రమబద్ధీకరించబడిన స్ట్రింగ్) ఇన్పుట్ [i] విలువను వెనక్కి నెట్టండి.
  4. ప్రతి పుష్బ్యాక్ విలువను తుది సెట్‌లోకి ఉపయోగించడం.
  5. చివరి సెట్‌ను ప్రింట్ చేయండి.

వివరణ

మొదట, మా ఇన్పుట్ సెట్ దీనిలో మా ఇన్పుట్ విలువలు పారామితిగా నిల్వ చేయబడతాయి. ఇక్కడ మేము ఒక పటాన్ని ప్రకటిస్తాము మరియు వెక్టర్ వరుసగా my_map మరియు final_set యొక్క వెక్టర్స్ వేరియబుల్. వెక్టర్ యొక్క పరిమాణం వచ్చే వరకు వెక్టర్‌ను మళ్ళించే లూప్ కోసం వస్తోంది. ఈ లూప్‌లో, మేము ఇన్పుట్ యొక్క ప్రతి సూచిక యొక్క విలువను ఒక కీలోకి తీసుకోబోతున్నాము.

కీలోని విలువ స్టోర్ మేము దానిని క్రమబద్ధీకరించబోతున్నాం, తద్వారా దాన్ని అనగ్రామ్‌గా తనిఖీ చేయవచ్చు మరియు ఇన్పుట్ యొక్క విలువను [i] మ్యాప్ యొక్క ముఖ్య స్థలంలో ఉంచండి, ఇక్కడ కీ క్రమబద్ధీకరించబడిన స్ట్రింగ్. మేము ఇన్పుట్ సెట్లోని అన్ని విలువలను మళ్ళించే వరకు ఇది కొనసాగుతుంది. మరియు మ్యాప్‌లోని అన్ని ముఖ్య విలువలను నిల్వ చేస్తుంది,

అప్పుడు మేము మై_మాప్ యొక్క అన్ని విలువలను వెక్టర్స్ యొక్క తుది సెట్ వెక్టర్లో చేర్చబోతున్నాము. చివరకు, దానిని ప్రింట్ చేయండి.

ఉదాహరణ

ఇన్పుట్ అనుకుందాం: [తినండి, టీ, టాన్, తిన్నది, నాట్, బ్యాట్]

క్రమబద్ధీకరించిన కీ = aet

కీ తినడానికి ఒక విలువగా నిల్వ చేయబోతోంది

మళ్ళీ, టీ యొక్క క్రమబద్ధీకరించబడిన కీ ఈట్ ఒక కీగా మరియు టీగా విలువగా నిల్వ చేయబోతోంది.

అన్ని పునరావృత్తులు చేసిన తరువాత:

aet (క్రమబద్ధీకరించిన స్ట్రింగ్): [తినండి, టీ, తిన్నారు] // కీ-విలువ జత

చీమ (క్రమబద్ధీకరించిన స్ట్రింగ్): [తాన్, చీమ] // కీ-విలువ జత

abt (క్రమబద్ధీకరించిన స్ట్రింగ్): [బ్యాట్] // కీ-విలువ జత

చివరికి, మేము అవుట్పుట్ పొందుతాము.

అమలు

గ్రూప్ అనాగ్రామ్స్ కోసం సి ++ ప్రోగ్రామ్

#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 అనేది ప్రతి పదానికి ఉన్న గరిష్ట అక్షరం.