సాధారణ అక్షరాల లీట్‌కోడ్ పరిష్కారాన్ని కనుగొనండి


కఠినత స్థాయి సులువు
తరచుగా అడుగుతుంది అమెజాన్ ఉబెర్
అర్రే హ్యాషింగ్

సమస్యల నివేదిక

ఈ సమస్యలో, మాకు జాబితా ఇవ్వబడింది స్ట్రింగ్. అన్ని తీగలలో సాధారణమైన అక్షరాలను మనం కనుగొనాలి. ఒక పాత్ర అన్ని తీగలలో బహుళ సార్లు ఉంటే, అప్పుడు మనం అక్షరాన్ని చాలాసార్లు అవుట్పుట్ చేయాలి.
మనకు తీగల శ్రేణి ఉందని అనుకుందాం
[“బెల్లా”, ”లేబుల్”, “రోలర్”]
'E' అక్షరం అన్ని తీగలలో ఒకసారి ఉంటుంది, l అన్ని తీగలలో రెండుసార్లు ఉంటుంది. ఇతర పాత్రలు సాధారణం కాదు.
కాబట్టి, మా అవుట్పుట్ జాబితాలో, 'ఇ' అక్షరం ఒకసారి మరియు 'ఎల్' అక్షరం రెండుసార్లు ఉంటుంది.

ఉదాహరణ

["bella","label","roller"]
["e","l","l"]
["cool","lock","cook"]
["c","o"]

అప్రోచ్

అక్షరాల యొక్క సాధారణ పౌన frequency పున్యాన్ని ఇక్కడ అన్ని తీగలలో కనుగొనవలసి ఉందని మనం చూడవచ్చు.
ప్రతి స్ట్రింగ్ కోసం మేము పరిమాణం 26 యొక్క గణన శ్రేణిని సృష్టించవచ్చు, ఇది అక్షరాల యొక్క ఫ్రీక్వెన్సీని కలిగి ఉంటుంది. ఇండెక్స్ 0 లో ఆ స్ట్రింగ్‌లో 'a' లెక్కింపు ఉంటుంది మరియు ఇండెక్స్ 1 లో 'బి' లెక్కింపు ఉంటుంది.
ఇప్పుడు a నుండి z వరకు ఉన్న ప్రతి అక్షరం కోసం, పైన సృష్టించిన ఏదైనా శ్రేణులలో ఉండే కనీస గణనను మనం కనుగొనాలి. మేము దీన్ని చేస్తున్నాము, ఎందుకంటే అన్ని తీగలలో పాత్ర యొక్క కనీస ఉనికిపై మాకు ఆసక్తి ఉంది. మరో మాటలో చెప్పాలంటే, మేము ప్రతి స్ట్రింగ్ నుండి సాధారణ అక్షరాలను మాత్రమే తీసుకుంటున్నాము.

 

సాధారణ అక్షరాల లీట్‌కోడ్ పరిష్కారాన్ని కనుగొనండి

కాబట్టి, మేము మొదట ఒక జవాబును సృష్టిస్తాము అమరిక పరిమాణం 26 యొక్క అన్ని సూచికలను గరిష్ట విలువతో సెట్ చేస్తుంది.
అప్పుడు, మేము తీగల శ్రేణిని ఎడమ నుండి కుడికి ప్రయాణిస్తాము. ప్రతి దశలో, ప్రస్తుత స్ట్రింగ్ కోసం కౌంట్ శ్రేణిని సృష్టిస్తాము. అప్పుడు మేము ప్రస్తుతం సృష్టించిన శ్రేణిని అన్స్ అర్రేతో పోలుస్తాము.
మనకు అన్నింటికన్నా కనీసం ఆసక్తి ఉన్నందున, ప్రస్తుత శ్రేణిలోని విలువ ఆ సూచికలోని అన్స్ శ్రేణి విలువ కంటే తక్కువగా ఉంటే మాత్రమే అన్స్ శ్రేణి యొక్క ప్రతి సూచిక సవరించబడుతుంది.
అనగా ans [i]

మేము ఇచ్చిన జాబితా యొక్క అన్ని తీగలను దాటిన తరువాత, అక్షరాల జాబితాను సృష్టించడానికి మేము మా అన్స్ శ్రేణిని ఉపయోగిస్తాము. జవాబు శ్రేణిలో, ఇండెక్స్ 0 వద్ద ఉన్న విలువ 'a' అక్షర గణనను చూపుతుంది, ఇండెక్స్ 1 వద్ద ఉన్న విలువ సూచిక 'బి' యొక్క సంఖ్యను చూపిస్తుంది.
కాబట్టి, ఈ విధంగా ప్రతి అక్షరం యొక్క గణనను a నుండి z వరకు ఉపయోగించడం ద్వారా మన అవుట్పుట్ అక్షరాల శ్రేణిని చేస్తాము.

అమలు

సాధారణ అక్షరాలను కనుగొనటానికి సి ++ ప్రోగ్రామ్ లీట్‌కోడ్ సొల్యూషన్

#include <iostream>
#include <vector>
using namespace std;
vector<string> commonChars(vector<string>& A) {
        int ans[26];
        int temp[26];
        fill(ans,ans+26,100);
        for(string str:A){
            fill(temp, temp+26,0);
            for(int i=0;i<str.size();i++){
                temp[str[i]-'a']++;
            }
            for(int i=0;i<26;i++){
                ans[i]=min(ans[i],temp[i]);
            }
        }
        vector<string>ansChars;
        for(int i=0;i<26;i++){
            for(int j=0;j<ans[i];j++){
                char ch=((char)(i+'a'));
                string s(1, ch); //convert char ch to string s
                ansChars.push_back(s);
            }
        }
        return ansChars;
    }
int main()
{
    vector<string>A{"bella","label","roller"};
    vector<string>ans = commonChars(A);
    for(string str:ans){
        cout<<str<<" ";
    }
    cout<<endl;
}
e l l

సాధారణ అక్షరాలను కనుగొనడానికి జావా ప్రోగ్రామ్ లీట్‌కోడ్ పరిష్కారం

import java.util.*;
import java.lang.*;

class Solution
{  
    public static void main(String args[])
    {
        String[]A={"bella","label","roller"};
        List<String>ans=commonChars(A);
        for(String str:ans){
            System.out.print(str+" ");
        }
        System.out.println();
    }
    public static List<String> commonChars(String[] A) {
        int[]ans=new int[26];
        int[]temp=new int[26];
        Arrays.fill(ans,Integer.MAX_VALUE);
        for(String str:A){
            Arrays.fill(temp,0);
            for(int i=0;i<str.length();i++){
                temp[str.charAt(i)-'a']++;
            }
            for(int i=0;i<26;i++){
                ans[i]=Math.min(ans[i],temp[i]);
            }
        }
        List<String>ansChars=new ArrayList<String>();
        for(int i=0;i<ans.length;i++){
            for(int j=0;j<ans[i];j++){
                ansChars.add((char)(i+'a')+"");
            }
        }
        return ansChars;
    }
}
e l l

సాధారణ అక్షరాలను కనుగొనటానికి సంక్లిష్టత విశ్లేషణ లీట్‌కోడ్ పరిష్కారం

సమయం సంక్లిష్టత

పై): ఇక్కడ n అనేది అన్ని తీగల పొడవు.

అంతరిక్ష సంక్లిష్టత 

ఓ (1): రెండు శ్రేణుల అన్స్ మరియు టెంప్, ప్రతి పరిమాణం 26 ఉపయోగించబడుతుంది. ఇది స్థిరమైన సైజు మెమరీ తప్ప మరొకటి కాదు. అందువల్ల స్థల సంక్లిష్టత O (1).