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


కఠినత స్థాయి సులువు
తరచుగా అడుగుతుంది Adobe అమెజాన్ ఆపిల్ బ్లూమ్బెర్గ్ గూగుల్ మైక్రోసాఫ్ట్ ట్రిప్అడ్వైజర్ ఉబెర్
అల్గోరిథంలు అర్రే కోడింగ్ హ్యాషింగ్ ఇంటర్వ్యూ ఇంటర్వ్యూ ప్రిపరేషన్ లీట్‌కోడ్ LeetCodeSolutions

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

ఈ సమస్యలో, మాకు ఒక ఇవ్వబడుతుంది అమరిక of తీగలను. శ్రేణిలోని ప్రతి స్ట్రింగ్‌లో కనిపించే అన్ని అక్షరాల జాబితాను మేము ముద్రించాలి (నకిలీలు చేర్చబడ్డాయి). అంటే ప్రతి స్ట్రింగ్‌లో ఒక అక్షరం 2 సార్లు కనిపిస్తుంది, కానీ 3 సార్లు కాదు, ఫలితంలో మనకు 2 సార్లు ఉండాలి.

స్ట్రింగ్‌లోని ప్రతి అక్షరం లోయర్-కేస్ ఇంగ్లీష్ అక్షరం మరియు తీగలకు గరిష్టంగా 100 పొడవు ఉంటుందని గమనించండి.

ఉదాహరణ

String_Array = {"bella" , "ciao" , "espanol"}
a
String_Array = {"qweerty" , "weerty" , "eerty"}
e e r t y

 

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

అప్రోచ్ (హాష్ మ్యాప్స్ 

మేము మొదట హ్యాష్‌మ్యాప్‌ను ఉపయోగించవచ్చు, చెప్పండి ఫైనల్ కౌంట్ ['a', 'z'] పరిధిలోని అక్షరాల గణనలను నిల్వ చేయడానికి కనిష్ట సాధారణం అన్ని తీగలలో ఉనికి. ఉదాహరణకు, శ్రేణిలోని ప్రతి స్ట్రింగ్‌లో 2 'ఇ'లు ఉన్నాయని మేము కనుగొంటే, మేము దాని గణనను 2 గా ఉంచుతాము. దీన్ని సాధించడానికి, మేము శ్రేణిలోని ప్రతి స్ట్రింగ్ ద్వారా సందర్శించి, కనిష్టీకరిస్తాము ఫైనల్ కౌంట్ ['a', 'z'] లోని ప్రతి అక్షరానికి. చివరగా, ఫలిత శ్రేణి / జాబితాలో ఒక అక్షరాన్ని దాని చివరి గణన ప్రకారం నెట్టివేసి, దానిని తిరిగి ఇస్తాము.

అల్గారిథం

  1. హాష్ మ్యాప్‌ను ప్రారంభించండి ఫైనల్ కౌంట్ ప్రతి పాత్ర యొక్క కనీస సాధారణ రూపాన్ని నిల్వ చేయడానికి
  2. ప్రతి చిన్న-ఆంగ్ల అక్షరాల కోసం:
    • వారి సెట్ ఫైనల్ కౌంట్ 100 గా.
  3. ప్రతి స్ట్రింగ్ కోసం పదం ఇచ్చిన శ్రేణిలో:
    • ప్రతి అక్షర గణనను హాష్ మ్యాప్‌లో నిల్వ చేయండి కౌంట్
    • ప్రతి చిన్న-ఆంగ్ల అక్షరానికి c:
      • సెట్: ఫైనల్ కౌంట్ [సి] = నాకు (ఫైనల్ కౌంట్ [సి], కౌంట్ [సి])
  4. జాబితా / శ్రేణిని ప్రారంభించండి ఫలితంగా సాధారణ అక్షరాల శ్రేణిని నిల్వ చేయడానికి.
  5. ప్రతి పాత్రకు ['a', 'z'] పరిధిలో:
    • జాబితాకు ఎన్నిసార్లు జోడించండి ఫైనల్ కౌంట్ [సి]
  6. ఫలితాన్ని ముద్రించండి
ఇది కూడ చూడు
కీబోర్డ్ వరుస లీట్‌కోడ్ పరిష్కారం

ఫైండ్ కామన్ క్యారెక్టర్స్ లీట్‌కోడ్ సొల్యూషన్ అమలు

సి ++ ప్రోగ్రామ్

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

vector <string> commonChars(vector <string> A)
{
    unordered_map <char , int> finalCount;

    for(char c = 'a' ; c <= 'z' ; ++c)
        finalCount[c] = 100;

    unordered_map <char , int> count;

    for(string &word : A)
    {
        count.clear();
        for(char c : word)
            count[c]++;

        for(char c = 'a' ; c <= 'z' ; ++c)
            finalCount[c] = min(finalCount[c] , count[c]);
    }

    vector <string> result;

    string temp;

    int times;
    for(char c = 'a' ; c <= 'z' ; ++c)
    {
        times = finalCount[c];
        temp = c;
        while(times > 0)
        {
            result.push_back(temp);
            --times;
        }
    }
    return result;
}

int main()
{
    vector <string> A = {"qweerty" , "weerty" , "eerty"};
    vector <string> result = commonChars(A);
    if(result.empty())
        cout << "No common characters\n";
    else
    {
        for(string &s : result)
            cout << s << " ";
    }

    return 0;
}

జావా ప్రోగ్రామ్

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

class common_chars
{
    public static void main(String args[])
    {
        String[] A = {"qweerty" , "weerty" , "eerty"};
        List <String> result = commonChars(A);
        if(result.size() == 0)
            System.out.println("No common characters");
        else
        {
            for(String s : result)
                System.out.print(s + " ");
        }
    }

    static List <String> commonChars(String[] A)
    {
        HashMap <Character , Integer> finalCount = new HashMap<>();

        for(char c = 'a' ; c <= 'z' ; ++c)
            finalCount.put(c , 100);

        HashMap <Character , Integer> count = new HashMap<>();
        for(String word : A)
        {
            count.clear();
            for(char c : word.toCharArray())
                count.put(c , count.getOrDefault(c , 0) + 1);

            for(char c = 'a' ; c <= 'z' ; ++c)
                finalCount.put(c , Math.min(finalCount.get(c) , count.getOrDefault(c , 0)));
        }

        List <String> result = new ArrayList<>();

        int times;
        for(char c = 'a' ; c <= 'z' ; ++c)
        {
            times = finalCount.get(c);
            while(times > 0)
            {
                result.add(Character.toString(c));
                --times;
            }
        }
        return result;
    }
}
e e r t y

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

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

పై) అక్షరాల గణనలను నవీకరించడానికి శ్రేణిలోని ప్రతి స్ట్రింగ్ యొక్క ఒకే పాస్ చేస్తున్నప్పుడు. N = శ్రేణిలోని తీగల పొడవు.

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

O (1) అక్షరాల గణనలను నిల్వ చేయడానికి మేము స్థిరమైన మెమరీ స్థలాన్ని ఉపయోగిస్తాము.

1