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


ತೊಂದರೆ ಮಟ್ಟ ಸುಲಭ
ಆಗಾಗ್ಗೆ ಕೇಳಲಾಗುತ್ತದೆ ಅಮೆಜಾನ್ ಉಬರ್
ಅಲ್ಗಾರಿದಮ್ಗಳು ಅರೇ ಕೋಡಿಂಗ್ ಹ್ಯಾಶಿಂಗ್ ಸಂದರ್ಶನ ಸಂದರ್ಶನ ಪೂರ್ವಭಾವಿ ಲೀಟ್‌ಕೋಡ್ LeetCodeSolutions

ಸಮಸ್ಯೆ ಹೇಳಿಕೆ  

ಈ ಸಮಸ್ಯೆಯಲ್ಲಿ, ನಮಗೆ ಪಟ್ಟಿಯನ್ನು ನೀಡಲಾಗಿದೆ ಸ್ಟ್ರಿಂಗ್. ಎಲ್ಲಾ ತಂತಿಗಳಲ್ಲಿ ಸಾಮಾನ್ಯವಾಗಿರುವ ಅಕ್ಷರಗಳನ್ನು ನಾವು ಕಂಡುಹಿಡಿಯಬೇಕು. ಒಂದು ಪಾತ್ರವು ಎಲ್ಲಾ ತಂತಿಗಳಲ್ಲಿ ಅನೇಕ ಬಾರಿ ಇದ್ದರೆ, ನಾವು ಅಕ್ಷರವನ್ನು ಅನೇಕ ಬಾರಿ output ಟ್‌ಪುಟ್ ಮಾಡಬೇಕು.
ನಾವು ತಂತಿಗಳ ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿದ್ದೇವೆ ಎಂದು ಭಾವಿಸೋಣ
[“ಬೆಲ್ಲಾ”, “ಲೇಬಲ್”, “ರೋಲರ್”]
ನಾವು ನೋಡಬಹುದು, 'ಇ' ಅಕ್ಷರವು ಎಲ್ಲಾ ತಂತಿಗಳಲ್ಲಿ ಒಮ್ಮೆ ಇರುತ್ತದೆ, ಎಲ್ ಎಲ್ಲಾ ತಂತಿಗಳಲ್ಲಿ ಎರಡು ಬಾರಿ ಇರುತ್ತದೆ. ಬೇರೆ ಯಾವುದೇ ಪಾತ್ರ ಸಾಮಾನ್ಯವಲ್ಲ.
ಆದ್ದರಿಂದ, ನಮ್ಮ output ಟ್‌ಪುಟ್ ಪಟ್ಟಿಯಲ್ಲಿ, 'ಇ' ಅಕ್ಷರವು ಒಮ್ಮೆ ಮತ್ತು 'ಎಲ್' ಅಕ್ಷರ ಎರಡು ಬಾರಿ ಇರುತ್ತದೆ.

ಉದಾಹರಣೆ

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

ಅಪ್ರೋಚ್  

ಅಕ್ಷರಗಳ ಸಾಮಾನ್ಯ ಆವರ್ತನವನ್ನು ನಾವು ಎಲ್ಲಾ ತಂತಿಗಳಲ್ಲಿ ಕಂಡುಹಿಡಿಯಬೇಕು ಎಂದು ನಾವು ನೋಡಬಹುದು.
ಪ್ರತಿ ಸ್ಟ್ರಿಂಗ್‌ಗೆ ನಾವು ಗಾತ್ರ 26 ರ ಎಣಿಕೆ ರಚನೆಯನ್ನು ರಚಿಸಬಹುದು, ಅದು ಅಕ್ಷರಗಳ ಆವರ್ತನವನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಸೂಚ್ಯಂಕ 0 ಆ ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ 'ಎ' ಎಣಿಕೆ ಹೊಂದಿರುತ್ತದೆ ಮತ್ತು ಸೂಚ್ಯಂಕ 1 ರಲ್ಲಿ 'ಬಿ' ಎಣಿಕೆ ಇರುತ್ತದೆ.
ಈಗ a ನಿಂದ z ವರೆಗಿನ ಪ್ರತಿಯೊಂದು ಅಕ್ಷರಕ್ಕೂ, ಮೇಲೆ ರಚಿಸಲಾದ ಯಾವುದೇ ಸರಣಿಗಳಲ್ಲಿ ಇರಬಹುದಾದ ಕನಿಷ್ಠ ಎಣಿಕೆಯನ್ನು ನಾವು ಕಂಡುಹಿಡಿಯಬೇಕಾಗಿದೆ. ನಾವು ಇದನ್ನು ಮಾಡುತ್ತಿದ್ದೇವೆ, ಏಕೆಂದರೆ ಎಲ್ಲಾ ತಂತಿಗಳಲ್ಲಿ ಒಂದು ಪಾತ್ರದ ಕನಿಷ್ಠ ಉಪಸ್ಥಿತಿಯಲ್ಲಿ ನಾವು ಆಸಕ್ತಿ ಹೊಂದಿದ್ದೇವೆ. ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ನಾವು ಪ್ರತಿ ಸ್ಟ್ರಿಂಗ್‌ನಿಂದ ಸಾಮಾನ್ಯ ಅಕ್ಷರಗಳನ್ನು ಮಾತ್ರ ತೆಗೆದುಕೊಳ್ಳುತ್ತಿದ್ದೇವೆ.

ಸಹ ನೋಡಿ
ರೂಕ್ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರಕ್ಕಾಗಿ ಲಭ್ಯವಿರುವ ಕ್ಯಾಪ್ಚರ್‌ಗಳು

 

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

ಆದ್ದರಿಂದ, ನಾವು ಮೊದಲು ಉತ್ತರವನ್ನು ರಚಿಸುತ್ತೇವೆ ಸರಣಿ ಗಾತ್ರ 26 ರ ಎಲ್ಲಾ ಸೂಚ್ಯಂಕಗಳನ್ನು ಗರಿಷ್ಠ ಮೌಲ್ಯದಲ್ಲಿ ಹೊಂದಿಸಲಾಗಿದೆ.
ನಂತರ, ನಾವು ಎಡದಿಂದ ಬಲಕ್ಕೆ ತಂತಿಗಳ ಶ್ರೇಣಿಯನ್ನು ಹಾದುಹೋಗುತ್ತೇವೆ. ಪ್ರತಿ ಹಂತದಲ್ಲೂ, ಪ್ರಸ್ತುತ ಸ್ಟ್ರಿಂಗ್‌ಗಾಗಿ ನಾವು ಎಣಿಕೆ ರಚನೆಯನ್ನು ರಚಿಸುತ್ತೇವೆ. ನಂತರ ನಾವು ಪ್ರಸ್ತುತ ರಚಿಸಿದ ಅರೇ ಅನ್ನು ಅನ್ಸ್ ಅರೇನೊಂದಿಗೆ ಹೋಲಿಸುತ್ತೇವೆ.
ನಾವು ಎಲ್ಲಕ್ಕಿಂತ ಕನಿಷ್ಠ ಆಸಕ್ತಿ ಹೊಂದಿದ್ದೇವೆ, ಆದ್ದರಿಂದ ಪ್ರಸ್ತುತ ಶ್ರೇಣಿಯಲ್ಲಿನ ಮೌಲ್ಯವು ಆ ಸೂಚ್ಯಂಕದಲ್ಲಿನ ಅನ್ಸ್ ಅರೇ ಮೌಲ್ಯಕ್ಕಿಂತ ಚಿಕ್ಕದಾಗಿದ್ದರೆ ಮಾತ್ರ ಅನ್ಸ್ ಅರೇನ ಪ್ರತಿಯೊಂದು ಸೂಚ್ಯಂಕವನ್ನು ಮಾರ್ಪಡಿಸಲಾಗುತ್ತದೆ.
ಅಂದರೆ ಉತ್ತರ [i]

ಕೊಟ್ಟಿರುವ ಪಟ್ಟಿಯ ಎಲ್ಲಾ ತಂತಿಗಳನ್ನು ನಾವು ದಾಟಿದ ನಂತರ, ಅಕ್ಷರಗಳ ಪಟ್ಟಿಯನ್ನು ರಚಿಸಲು ನಾವು ನಮ್ಮ ಉತ್ತರ ಶ್ರೇಣಿಯನ್ನು ಬಳಸುತ್ತೇವೆ. ಉತ್ತರ ಶ್ರೇಣಿಯಲ್ಲಿ, ಸೂಚ್ಯಂಕ 0 ರಲ್ಲಿನ ಮೌಲ್ಯವು 'a' ಅಕ್ಷರಗಳ ಎಣಿಕೆ, ಸೂಚ್ಯಂಕ 1 ರಲ್ಲಿನ ಮೌಲ್ಯವು ಸೂಚ್ಯಂಕ 'b' ನ ಸಂಖ್ಯೆಯನ್ನು ತೋರಿಸುತ್ತದೆ.
ಆದ್ದರಿಂದ, ಈ ರೀತಿಯಾಗಿ ನಾವು ಪ್ರತಿ ಅಕ್ಷರಗಳ ಎಣಿಕೆಯನ್ನು a ನಿಂದ z ಗೆ ಬಳಸುವ ಮೂಲಕ ನಮ್ಮ output ಟ್‌ಪುಟ್ ಅರೇ ಅಕ್ಷರಗಳನ್ನು ಮಾಡುತ್ತೇವೆ.

ಅನುಷ್ಠಾನ  

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

#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 ಗಾತ್ರವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಇದು ಸ್ಥಿರ ಗಾತ್ರದ ಮೆಮೊರಿಯನ್ನು ಹೊರತುಪಡಿಸಿ ಏನೂ ಅಲ್ಲ. ಆದ್ದರಿಂದ ಬಾಹ್ಯಾಕಾಶ ಸಂಕೀರ್ಣತೆಯು ಒ (1) ಆಗಿದೆ.

1