టాప్ K తరచుగా పదాలు


కఠినత స్థాయి మీడియం
తరచుగా అడుగుతుంది అకోలైట్ ఫోర్కైట్స్ ఇన్ఫోసిస్
హ్యాషింగ్ కుప్ప ట్రీ

టాప్ K తరచుగా పదాల సమస్యలో, మేము పదాల జాబితాను మరియు పూర్ణాంక k ని ఇచ్చాము. జాబితాలో ఎక్కువగా ఉపయోగించే తీగలను ప్రింట్ చేయండి.

టాప్ K తరచుగా పదాలు

ఉదాహరణ

ఇన్పుట్:

జాబితా = code “కోడ్”, “ఆకాశం”, “పెన్”, “ఆకాశం”, “ఆకాశం”, “నీలం”, “కోడ్”}

k = 2

అవుట్పుట్: 

ఆకాశంలో

కోడ్

ఇన్పుట్:

జాబితా = {“అవును”, “లేదు”, “అవును”, “అవును”}

k = 1

అవుట్పుట్: 

అవును

టాప్ K తరచుగా పదాల కోసం వివరణ

ఇచ్చిన జాబితా = {“సిపిపి”, “జావా”, “జావా”, “సిపిపి”, “పైథాన్”, “జావా”, “సిపిపి”, “కోట్లిన్”, “కోట్లిన్”, “జావా” k మరియు కె = 3

ప్రతి పదం సంభవించిన మొత్తం సంఖ్య -

  • cpp ఇచ్చిన జాబితాలో 3 సార్లు సంభవించింది.
  • ఇచ్చిన జాబితాలో జావా 4 సార్లు సంభవించింది.
  • ఇచ్చిన జాబితాలో పైథాన్ 1 సార్లు సంభవించింది.
  • ఇచ్చిన జాబితాలో కోట్లిన్ 2 సార్లు సంభవించింది.

ప్రతి పదం సంభవించే సంఖ్య యొక్క క్రమాన్ని తగ్గించడం -

జావా, సిపిపి, కోట్లిన్, పైథాన్

అందువల్ల, ఇచ్చిన జాబితాలో తరచుగా ఉపయోగించే టాప్ k (అనగా 3) పదాలు -

  1. జావా
  2. సిపిపి
  3. కోట్లిన్

టాప్ K తరచుగా పదాల కోసం అల్గోరిథం

  1. పదాల జాబితాను ప్రారంభించండి మరియు పూర్ణాంకం k.
  2. మ్యాప్ మరియు ప్రాధాన్యతను ప్రారంభించండి క్యూ.
  3. జాబితా మరియు ఇంక్రిమెంట్ మ్యాప్ [జాబితా [i]] ను దాటండి.
  4. మ్యాప్‌లో ప్రయాణించి, ప్రాధాన్యత క్యూ యొక్క పరిమాణం k కన్నా తక్కువగా ఉందో లేదో తనిఖీ చేయండి.
  5. క్యూలోని అగ్ర మూలకం ప్రస్తుత మూలకం కంటే తక్కువగా ఉంటే, పై మూలకాన్ని తీసివేసి, క్యూలో ప్రస్తుత మూలకాన్ని చొప్పిస్తుంది.
  6. క్యూలోని ఎగువ మూలకం ప్రస్తుత మూలకానికి సమానంగా ఉంటే మరియు ప్రస్తుత మూలకం యొక్క కీ కంటే ఎగువ మూలకం యొక్క కీ ఎక్కువగా ఉంటే పై మూలకాన్ని తీసివేసి ప్రస్తుత మూలకాన్ని క్యూలో చేర్చండి.
  7. ఖాళీ జాబితాను సృష్టించండి.
  8. క్యూలో ప్రయాణించి, దానిలోని టాప్ ఎలిమెంట్‌ను తాత్కాలిక వేరియబుల్‌లో నిల్వ చేయండి, టాప్ ఎలిమెంట్‌ను తొలగించి, క్రొత్త జాబితాలో దాని కీని నిల్వ చేయండి.
  9. క్రొత్త జాబితాను రివర్స్ చేసి తిరిగి ఇవ్వండి.

టాప్ k తరచుగా పదాలను కనుగొనడానికి సి ++ ప్రోగ్రామ్

#include <bits/stdc++.h>
using namespace std;

void frequent(vector<auto> v){
   for(int i = 0; i<v.size(); i++){
      cout<<v[i]<< endl;
   }
}

struct Comparator{
    bool operator()(pair <string ,int> a, pair <string, int> b){
        if(a.second != b.second) 
            return !(a.second < b.second);
        return !(a.first > b.first);
    }
};

class Solution{
    
    public:
        static bool cmp(pair <string, int> a, pair <string, int> b){
            if(a.second != b.second) 
                return a.second > b.second;
            return a.first < b.first;
        }
        
        vector<string> topFrequent(vector<string>& words, int k){
            map<string, int> m;
            
            priority_queue < pair <string, int>, vector < pair <string, int> >, Comparator > v;
            
            for(int i = 0; i < words.size(); i++){
                m[words[i]]++;
            }
            
            map<string, int> :: iterator i = m.begin();
            
            while(i != m.end()){
                if(v.size() < k){
                    v.push(*i);
                }
                else if(v.top().second < i->second){
                    v.pop();
                    v.push(*i);
                }
                else if(v.top().second == i->second && v.top().first > i->first){
                    v.pop();
                    v.push(*i);
                }
                i++;
            }
            
            vector <string> res;
            
            while(!v.empty()){
                pair <string, int> temp = v.top();
                v.pop();
                res.push_back(temp.first);
            }
            
            reverse(res.begin(), res.end());
            return res;
        }
};

int main(){
    
   Solution s;
   
   vector<string> v = {"code", "sky", "pen", "sky", "sky", "blue", "code"};
   int k = 2;
   frequent(s.topFrequent(v, k));
   
   return 0;
   
}
sky
code

టాప్ k తరచుగా పదాలను కనుగొనడానికి జావా ప్రోగ్రామ్

import java.util.*;

class text{
    public List<String> topKFrequentAlternate(final String[] words, int k) {
    	final Map<String, Integer> freq = new HashMap<>();
    	
    	final Queue<WordFreq> queue = new PriorityQueue<>((w1, w2) -> {
    		if (w1.getFreq() != w2.getFreq()) {
    			return w1.getFreq() - w2.getFreq();
    		}
    		return w2.getWord().compareTo(w1.getWord());
    	});
    	
    	final List<String> result = new ArrayList<>();
    
    	for (final String word : words) {
    		if (freq.containsKey(word)) {
    			final int count = freq.get(word);
    			freq.put(word, count + 1);
    		} else {
    			freq.put(word, 1);
    		}
    	}
    
    	for (final Map.Entry<String, Integer> entry : freq.entrySet()) {
    		queue.offer(new WordFreq(entry.getKey(), entry.getValue()));
    
    		if (queue.size() > k) {
    			queue.poll();
    		}
    	}
    
    	while (k-- > 0) {
    		result.add(queue.poll().getWord());
    	}
    
    	Collections.reverse(result);
    	return result;
    }
}
class WordFreq {
  private final String word;
  private final int freq;

  WordFreq(final String word, final int freq) {
    this.word = word;
    this.freq = freq;
  }

  String getWord() {
    return this.word;
  }

  int getFreq() {
    return this.freq;
  }

  @Override
  public String toString() {
    return Objects.toString(word) + "->" + Objects.toString(freq);
  }
  
  public static void main (String[] args){
      text t = new text();
      String[] words = {"code", "sky", "pen", "sky", "sky", "blue", "code"};
      int k = 2;
      List<String> res = new ArrayList<String>();
      res = t.topKFrequentAlternate(words,k);
        ListIterator<String> lItr = res.listIterator();
    while (lItr.hasNext()){
      System.out.println(lItr.next());
    }
  }
}
sky
code

ప్రస్తావనలు