ਸਟ੍ਰੇਟਸ ਦੀ ਤੁਲਨਾ ਛੋਟੇ ਆਕਾਰ ਦੇ ਲੈਟਕੋਡ ਘੋਲ ਦੀ ਬਾਰੰਬਾਰਤਾ ਨਾਲ ਕਰੋ


ਮੁਸ਼ਕਲ ਪੱਧਰ ਸੌਖੀ
ਅਕਸਰ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ ਗੂਗਲ ਓਰੇਕਲ
ਅਰੇ ਸਤਰ

ਸਮੱਸਿਆ ਸਟ੍ਰਿੰਗਜ਼ ਦੀ ਤੁਲਨਾ ਛੋਟੇ ਆਕਾਰ ਦੇ ਲੀਟਰਕੋਡ ਸਲਿ Sਸ਼ਨ ਦੀ ਬਾਰੰਬਾਰਤਾ ਦੁਆਰਾ ਕੀਤੀ ਗਈ ਹੈ, ਕਹਿੰਦਾ ਹੈ ਕਿ ਅਸੀਂ ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ f (s) ਨੂੰ ਇੱਕ ਖਾਲੀ ਨਹੀਂ ਸਤਰ s ਜਿਵੇਂ ਕਿ f (s) ਸਤਰ ਦੇ ਛੋਟੇ ਅੱਖਰਾਂ ਦੀ ਬਾਰੰਬਾਰਤਾ ਦੇ ਬਰਾਬਰ ਹੈ. ਫਿਰ ਸਾਨੂੰ ਕੁਝ ਸ਼ਬਦ ਅਤੇ ਕੁਝ ਪ੍ਰਸ਼ਨ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ. ਹਰ ਇੱਕ ਪੁੱਛਗਿੱਛ ਲਈ, ਸਾਨੂੰ ਸ਼ਬਦ (f) (f) (f) (f) (f) ਸ਼ਬਦ (ਕਿ wordsਰੀ_ਵਰਡ) ਦੀ ਸੰਖਿਆ ਲੱਭਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ. ਫਿਰ ਸਾਨੂੰ ਸਾਰੀਆਂ ਪ੍ਰਸ਼ਨਾਂ ਦਾ ਉੱਤਰ ਵੈਕਟਰ ਜਾਂ ਐਰੇ ਵਜੋਂ ਵਾਪਸ ਕਰਨਾ ਪਏਗਾ. ਇਸ ਲਈ, ਘੋਲ ਨੂੰ ਡੂੰਘਾਈ ਨਾਲ ਜਾਣ ਤੋਂ ਪਹਿਲਾਂ, ਆਓ ਕੁਝ ਉਦਾਹਰਣਾਂ 'ਤੇ ਝਾਤ ਮਾਰੀਏ.

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

ਸਪੱਸ਼ਟੀਕਰਨ: f (“zaaaz”) = 3, ਕਿਉਂਕਿ ਸਭ ਤੋਂ ਛੋਟਾ ਅੱਖਰ 'a' ਹੈ ਜਿਸ ਦੀ ਬਾਰੰਬਾਰਤਾ 3 ਦੇ ਬਰਾਬਰ ਹੈ, ਜਦੋਂ ਕਿ f ("cbd") = 1. ਸੋ, ਸਾਡੇ ਕੋਲ ਸਿਰਫ ਇਕੋ ਸ਼ਬਦ ਹੈ ਜਿਸਦਾ f (i) ਹੈ )> ਐਫ (ਪੁੱਛਗਿੱਛ_ ਸ਼ਬਦ).

ਸਟ੍ਰੇਟਸ ਦੀ ਤੁਲਨਾ ਛੋਟੇ ਆਕਾਰ ਦੇ ਲੈਟਕੋਡ ਘੋਲ ਦੀ ਬਾਰੰਬਾਰਤਾ ਨਾਲ ਕਰੋ

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

ਵਿਆਖਿਆ: ਇਸ ਲਈ, ਸਾਰੇ ਦਿੱਤੇ ਸ਼ਬਦਾਂ ਲਈ ਪਰਿਭਾਸ਼ਤ ਫੰਕਸ਼ਨ ਦੇ ਮੁੱਲ ਦੀ ਗਣਨਾ ਕਰਨ ਤੋਂ ਬਾਅਦ. ਅਸੀਂ f (“a”) = 1, f (“aa”) = 2, f (“aaa”) = 3, f (“aaa”) = 4. ਵਿਚ ਦਿੱਤੇ ਸ਼ਬਦਾਂ ਲਈ ਫੰਕਸ਼ਨ ਦੇ ਮੁੱਲ ਦਾ ਮੁਲਾਂਕਣ ਕਰਨ ਤੋਂ ਬਾਅਦ ਪਾਉਂਦੇ ਹਾਂ। ਕਿeriesਰੀਆਂ, ਅਸੀਂ f (“bbb”) = 3, f (“cc”) = 2. ਲੱਭਦੇ ਹਾਂ, ਫੇਰ ਸਾਨੂੰ ਪਤਾ ਚਲਦਾ ਹੈ ਕਿ f (“bbb”) ਸ਼ਬਦ ਲਈ, ਸਾਡੇ ਕੋਲ ਇਕੋ ਸ਼ਬਦ “aaa” ਹੈ ਜਿਸ ਦਾ ਫੰਕਸ਼ਨ ਵੈਲਯੂ ਹੈ। 3 ਤੋਂ ਵੱਡਾ। ਇਸੇ ਤਰ੍ਹਾਂ, “ਸੀਸੀ” ਸ਼ਬਦ ਲਈ, ਸਾਡੇ ਕੋਲ ਸ਼ਬਦ “ਏਏਏ”, “ਏਏਏਏ” ਹਨ ਜਿਨ੍ਹਾਂ ਦਾ ਫੰਕਸ਼ਨ ਦਾ ਮੁੱਲ ਜ਼ਿਆਦਾ ਹੁੰਦਾ ਹੈ।

ਛੋਟੇ ਚਰਿੱਤਰ ਲੀਟਕੋਡ ਘੋਲ ਦੀ ਬਾਰੰਬਾਰਤਾ ਦੁਆਰਾ ਸਟ੍ਰਿੰਗਜ਼ ਦੀ ਤੁਲਨਾ ਕਰਨ ਲਈ ਪਹੁੰਚ

ਸਮੱਸਿਆ ਸਟ੍ਰਿੰਗਜ਼ ਦੀ ਤੁਲਨਾ ਛੋਟੇ ਅੱਖਰਾਂ ਦੀ ਬਾਰੰਬਾਰਤਾ ਦੁਆਰਾ ਕਰੋ ਲੀਟਕੋਡ ਸਲਿ theਸ਼ਨ ਇਨਪੁਟ ਵਿੱਚੋਂ ਉਨ੍ਹਾਂ ਸ਼ਬਦਾਂ ਦੀ ਗਿਣਤੀ ਲੱਭਣ ਲਈ ਪੁੱਛਦਾ ਹੈ ਜਿਹਨਾਂ ਲਈ ਕਿ queryਰੀ ਸ਼ਬਦਾਂ ਦੇ ਫੰਕਸ਼ਨ ਦੇ ਮੁੱਲ ਨਾਲੋਂ ਪਰਿਭਾਸ਼ਤ ਫੰਕਸ਼ਨ ਲਈ ਮੁੱਲ ਹੁੰਦਾ ਹੈ. ਫੰਕਸ਼ਨ f (s) ਨਾ-ਖਾਲੀ ਸਤਰਾਂ ਉੱਤੇ ਪਰਿਭਾਸ਼ਤ ਇੱਕ ਸਤਰ ਵਿੱਚ ਛੋਟੇ ਅੱਖਰ ਦੀ ਬਾਰੰਬਾਰਤਾ ਦੇ ਬਰਾਬਰ ਹੈ. ਤਾਂ, ਪਹਿਲਾਂ, ਅਸੀਂ ਸਾਰੇ ਕਿ theਰੀ ਸ਼ਬਦਾਂ ਲਈ ਫੰਕਸ਼ਨ ਦਾ ਮੁੱਲ ਪਾਉਂਦੇ ਹਾਂ. ਅਸੀਂ ਸਾਰੇ ਇਨਪੁਟ ਸ਼ਬਦਾਂ ਲਈ ਇਹੀ ਕਰਦੇ ਹਾਂ. ਅਸੀਂ ਇੱਕ ਵਾਧੂ ਐਰੇ ਵੀ ਬਣਾਉਂਦੇ ਹਾਂ ਜੋ ਸ਼ਬਦਾਂ ਦੀ ਸੰਖਿਆ ਨੂੰ ਸਟੋਰ ਕਰਦਾ ਹੈ ਜਿਸਦਾ ਫੰਕਸ਼ਨ ਵੈਲਯੂ i ਦੇ ਬਰਾਬਰ ਹੁੰਦਾ ਹੈ. ਇਹ ਐਰੇ ਸਾਨੂੰ ਨਿਰੰਤਰ ਸਮੇਂ ਵਿੱਚ ਪ੍ਰਸ਼ਨਾਂ ਦੇ ਜਵਾਬ ਲੱਭਣ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰੇਗੀ. ਐਰੇ ਦਾ ਹਰੇਕ ਇੰਡੈਕਸ 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 ਦੇ ਵਾਧੂ ਐਰੇ ਬਣਾਉਂਦੇ ਹਾਂ. ਪੁਲਾੜ ਦੀ ਜਟਿਲਤਾ ਵੀ ਲੀਨੀਅਰ ਹੈ.