ಸಣ್ಣ ಅಕ್ಷರ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದ ಆವರ್ತನದಿಂದ ತಂತಿಗಳನ್ನು ಹೋಲಿಕೆ ಮಾಡಿ


ತೊಂದರೆ ಮಟ್ಟ ಸುಲಭ
ಆಗಾಗ್ಗೆ ಕೇಳಲಾಗುತ್ತದೆ ಗೂಗಲ್ ಒರಾಕಲ್
ಅರೇ ಸ್ಟ್ರಿಂಗ್

ಸಣ್ಣ ಅಕ್ಷರ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದ ಆವರ್ತನದಿಂದ ತಂತಿಗಳನ್ನು ಹೋಲಿಸಿ, ಖಾಲಿ ಇಲ್ಲದ ಮೇಲೆ ನಾವು ಎಫ್ (ಗಳನ್ನು) ಕಾರ್ಯವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ ಎಂದು ಹೇಳುತ್ತದೆ ಸ್ಟ್ರಿಂಗ್ ಅಂದರೆ ಎಫ್ (ಗಳು) ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿನ ಚಿಕ್ಕ ಅಕ್ಷರಗಳ ಆವರ್ತನಕ್ಕೆ ಸಮಾನವಾಗಿರುತ್ತದೆ. ನಂತರ ನಮಗೆ ಕೆಲವು ಪದಗಳು ಮತ್ತು ಕೆಲವು ಪ್ರಶ್ನೆಗಳನ್ನು ನೀಡಲಾಗುತ್ತದೆ. ಪ್ರತಿ ಪ್ರಶ್ನೆಗೆ, ಎಫ್ (ಪದಗಳು)> ಎಫ್ (ಪ್ರಶ್ನೆ_ವರ್ಡ್‌) ಪದಗಳ ಸಂಖ್ಯೆಯನ್ನು ನಾವು ಕಂಡುಹಿಡಿಯಬೇಕಾಗಿದೆ. ನಂತರ ನಾವು ಎಲ್ಲಾ ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತರವನ್ನು ವೆಕ್ಟರ್ ಅಥವಾ ಅರೇ ಆಗಿ ಹಿಂದಿರುಗಿಸಬೇಕು. ಆದ್ದರಿಂದ, ದ್ರಾವಣದಲ್ಲಿ ಆಳವಾಗಿ ಧುಮುಕುವ ಮೊದಲು, ಕೆಲವು ಉದಾಹರಣೆಗಳನ್ನು ನೋಡೋಣ.

queries = ["cbd"], words = ["zaaaz"]
[1]

ವಿವರಣೆ: f (“a ಾ az ್”) = 3, ಏಕೆಂದರೆ ಚಿಕ್ಕ ಅಕ್ಷರವು 'a' ಆಗಿದ್ದು ಅದು 3 ಕ್ಕೆ ಸಮನಾದ ಆವರ್ತನವನ್ನು ಹೊಂದಿರುತ್ತದೆ, ಆದರೆ f (“cbd”) = 1. ಆದ್ದರಿಂದ, ನಮ್ಮಲ್ಲಿ f (i )> f (ಪ್ರಶ್ನೆ_ವರ್ಡ್‌).

ಸಣ್ಣ ಅಕ್ಷರ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದ ಆವರ್ತನದಿಂದ ತಂತಿಗಳನ್ನು ಹೋಲಿಕೆ ಮಾಡಿ

queries = ["bbb","cc"], words = ["a","aa","aaa","aaaa"]
[1,2]

ವಿವರಣೆ: ಆದ್ದರಿಂದ, ಕೊಟ್ಟಿರುವ ಎಲ್ಲಾ ಪದಗಳಿಗೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಕಾರ್ಯದ ಮೌಲ್ಯವನ್ನು ಲೆಕ್ಕಹಾಕಿದ ನಂತರ. ನಾವು f (“a”) = 1, f (“aa”) = 2, f (“aaa”) = 3, f (“aaaa”) = 4. ಅನ್ನು ನೀಡಿರುವ ಪದಗಳಿಗೆ ಕ್ರಿಯೆಯ ಮೌಲ್ಯವನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಿದ ನಂತರ ಪ್ರಶ್ನೆಗಳು, ನಾವು f (“bbb”) = 3, f (“cc”) = 2. ಆದ್ದರಿಂದ, f (“bbb”) ಪದಕ್ಕೆ, “aaaa” ಎಂಬ ಒಂದೇ ಪದವನ್ನು ನಾವು ಹೊಂದಿದ್ದೇವೆ ಅದು ಕಾರ್ಯ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆ 3 ಕ್ಕಿಂತ ದೊಡ್ಡದಾಗಿದೆ. ಅದೇ ರೀತಿ, “ಸಿಸಿ” ಪದಕ್ಕೆ, ನಮ್ಮಲ್ಲಿ “ಆಆ”, “ಆಆಆ” ಪದಗಳು ಹೆಚ್ಚಿನ ಕಾರ್ಯ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿವೆ.

ಸಣ್ಣ ಅಕ್ಷರ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದ ಆವರ್ತನದಿಂದ ತಂತಿಗಳನ್ನು ಹೋಲಿಸುವ ವಿಧಾನ

ಸಣ್ಣ ಅಕ್ಷರ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದ ಆವರ್ತನದಿಂದ ತಂತಿಗಳನ್ನು ಹೋಲಿಸಿ ಸಮಸ್ಯೆ ಇನ್ಪುಟ್‌ನಿಂದ ಪದಗಳ ಸಂಖ್ಯೆಯನ್ನು ಕಂಡುಹಿಡಿಯಲು ಕೇಳುತ್ತದೆ, ಇದು ಪ್ರಶ್ನೆ ಪದಗಳ ಕ್ರಿಯೆಯ ಮೌಲ್ಯಕ್ಕಿಂತ ಹೆಚ್ಚಿನದಾದ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಕಾರ್ಯಕ್ಕೆ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಖಾಲಿ ಅಲ್ಲದ ತಂತಿಗಳ ಮೇಲೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಎಫ್ (ಗಳು) ಕಾರ್ಯವು ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿನ ಚಿಕ್ಕ ಅಕ್ಷರಗಳ ಆವರ್ತನಕ್ಕೆ ಸಮಾನವಾಗಿರುತ್ತದೆ. ಆದ್ದರಿಂದ, ಮೊದಲು, ಎಲ್ಲಾ ಪ್ರಶ್ನೆ ಪದಗಳಿಗೆ ನಾವು ಕ್ರಿಯೆಯ ಮೌಲ್ಯವನ್ನು ಕಂಡುಕೊಳ್ಳುತ್ತೇವೆ. ಎಲ್ಲಾ ಇನ್ಪುಟ್ ಪದಗಳಿಗೆ ನಾವು ಅದೇ ರೀತಿ ಮಾಡುತ್ತೇವೆ. ನಾನು ಕಾರ್ಯ ಶ್ರೇಣಿಯನ್ನು i ಗೆ ಸಮಾನವಾದ ಪದಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸಂಗ್ರಹಿಸುವ ಹೆಚ್ಚುವರಿ ಶ್ರೇಣಿಯನ್ನು ಸಹ ರಚಿಸುತ್ತೇವೆ. ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತರಗಳನ್ನು ಸ್ಥಿರ ಸಮಯದಲ್ಲಿ ಹುಡುಕಲು ಈ ರಚನೆಯು ನಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ. ರಚನೆಯ ಪ್ರತಿಯೊಂದು ಸೂಚ್ಯಂಕವು ಕಾರ್ಯ ಮೌಲ್ಯ = i ಹೊಂದಿರುವ ಪದಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸೂಚಿಸುತ್ತದೆ.

ಕಾರ್ಯ ಮೌಲ್ಯವನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಿದ ನಂತರ ಮತ್ತು ಅವುಗಳನ್ನು ನಮ್ಮ ತಾತ್ಕಾಲಿಕ ಶ್ರೇಣಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಿದ ನಂತರ. ನಾವು ತಾತ್ಕಾಲಿಕ ರಚನೆಯ ಪ್ರತ್ಯಯ ಮೊತ್ತವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ, ಅಂದರೆ ಪ್ರತಿ ಸೂಚ್ಯಂಕವು ಈಗ ಕಾರ್ಯ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರುವ ಒಟ್ಟು ಅಥವಾ i ಗೆ ಸಮನಾದ ಒಟ್ಟು ಪದಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ. ಈಗ ನಾವು ಪ್ರತಿ ಪ್ರಶ್ನೆ ಪದದ ಉತ್ತರವನ್ನು ಒಂದು ಶ್ರೇಣಿಯಲ್ಲಿ ಅಥವಾ ವೆಕ್ಟರ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಿ ಅದನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತೇವೆ.

ಸಣ್ಣ ಅಕ್ಷರ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದ ಆವರ್ತನದಿಂದ ತಂತಿಗಳನ್ನು ಹೋಲಿಸುವ ಕೋಡ್

ಸಿ ++ ಕೋಡ್

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

vector<int> numSmallerByFrequency(vector<string>& queries, vector<string>& words) {
    vector<int> q;
    for(auto x: queries){
        int f[26] = {0};
        int mn = 26;
        for(auto y: x){
            f[y-'a']++;
            mn = min(mn, y-'a');
        }
        q.push_back(f[mn]);
    }

    int fr[12];memset(fr, 0, sizeof fr);
    for(auto x: words){
        int f[26] = {0};
        int mn = 26;
        for(auto y: x){
            f[y-'a']++;
            mn = min(mn, y-'a');
        }
        fr[f[mn]]++;
    }
    for(int i=9;i>=0;i--)
        fr[i] += fr[i+1];
    vector<int> ans;
    for(auto x: q){
        ans.push_back(fr[x+1]);
    }
    return ans;
}

int main(){
    vector<string> queries = {"bbb","cc"};
    vector<string> words = {"a","aa","aaa","aaaa"};

    vector<int> answer = numSmallerByFrequency(queries, words);
    for(auto x: answer)
        cout<<x<<" ";
}
1 2

ಜಾವಾ ಕೋಡ್

import java.util.*;
import java.lang.*;
import java.io.*;
 
class Main
{
    public static int[] numSmallerByFrequency(String[] queries, String[] words) {
        ArrayList<Integer> q = new ArrayList<Integer>();
        for(String x: queries){
            int[] f = new int[26];
            for(int i=0;i<26;i++)
                f[i] = 0;
            int mn = 26;
            int sz = x.length();
            for(int i=0;i<sz;i++){
                int y = x.charAt(i);
                f[y-'a']++;
                mn = Math.min(mn, y-'a');
            }
            q.add(f[mn]);
        }
 
        int[] fr = new int[12];
        for(int i=0;i<12;i++)
            fr[i] = 0;
        for(String x: words){
            int[] f = new int[26];
            for(int i=0;i<26;i++)
                f[i] = 0;
            int mn = 26;
            int sz = x.length();
            for(int i=0;i<sz;i++){
                int y = x.charAt(i);
                f[y-'a']++;
                mn = Math.min(mn, y-'a');
            }
            fr[f[mn]]++;
        }
        for(int i=9;i>=0;i--)
            fr[i] += fr[i+1];
        int[] ans = new int[queries.length];
        for(int i=0;i<q.size();i++){
            ans[i] = (fr[q.get(i)+1]);
        }
        return ans;
    }
 
  public static void main (String[] args) throws java.lang.Exception
  {
    String[] queries = {"bbb","cc"};
      String[] words = {"a","aa","aaa","aaaa"};
 
      int[] answer = numSmallerByFrequency(queries, words);
      for(int x: answer)
          System.out.print(x+" ");
  }
}
1 2

ಸಂಕೀರ್ಣತೆ ವಿಶ್ಲೇಷಣೆ

ಸಮಯ ಸಂಕೀರ್ಣತೆ

ಒ (ಕ್ಯೂ + ಎನ್), ನಾವು ಎಲ್ಲಾ ಪದಗಳ ಕಾರ್ಯ ಮೌಲ್ಯವನ್ನು ಲೆಕ್ಕ ಹಾಕಬೇಕಾಗಿರುವುದರಿಂದ ಮತ್ತು ಪದಗಳ ಉದ್ದವು 10 ಕ್ಕಿಂತ ಕಡಿಮೆ ಅಥವಾ ಸಮವಾಗಿರುತ್ತದೆ. ಹೀಗಾಗಿ ಸಮಯದ ಸಂಕೀರ್ಣತೆಯು ರೇಖೀಯವಾಗಿರುತ್ತದೆ.

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

ಒ (ಪ್ರ), ನಾವು ಉತ್ತರವನ್ನು ಸಂಗ್ರಹಿಸಲು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಮತ್ತು ತಾತ್ಕಾಲಿಕ ಬಳಕೆಗಾಗಿ ಗಾತ್ರ 10 ರ ಹೆಚ್ಚುವರಿ ಶ್ರೇಣಿಯನ್ನು ರಚಿಸುತ್ತೇವೆ. ಸ್ಥಳದ ಸಂಕೀರ್ಣತೆಯೂ ರೇಖೀಯವಾಗಿದೆ.