ಸಾಮಾನ್ಯ ಅಕ್ಷರಗಳ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರವನ್ನು ಹುಡುಕಿ  


ತೊಂದರೆ ಮಟ್ಟ ಸುಲಭ
ಆಗಾಗ್ಗೆ ಕೇಳಲಾಗುತ್ತದೆ ಅಡೋಬ್ ಅಮೆಜಾನ್ ಆಪಲ್ ಬ್ಲೂಮ್ಬರ್ಗ್ ಗೂಗಲ್ ಮೈಕ್ರೋಸಾಫ್ಟ್ ಟ್ರಿಪ್ ಅಡ್ವೈಸರ್ ಉಬರ್
ಅಲ್ಗಾರಿದಮ್ಗಳು ಅರೇ ಕೋಡಿಂಗ್ ಹ್ಯಾಶಿಂಗ್ ಸಂದರ್ಶನ ಸಂದರ್ಶನ ಪೂರ್ವಭಾವಿ ಲೀಟ್‌ಕೋಡ್ 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:
      • ಹೊಂದಿಸಿ: ಅಂತಿಮ ಲೆಕ್ಕ [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 = ರಚನೆಯಲ್ಲಿನ ತಂತಿಗಳ ಉದ್ದಗಳ ಮೊತ್ತ.

ಬಾಹ್ಯಾಕಾಶ ಸಂಕೀರ್ಣತೆ

ಒ (1) ಅಕ್ಷರಗಳ ಎಣಿಕೆಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ನಾವು ನಿರಂತರ ಮೆಮೊರಿ ಸ್ಥಳವನ್ನು ಬಳಸುತ್ತಿದ್ದೇವೆ.

1