ಅಕ್ಷರಗಳ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದಿಂದ ರೂಪಿಸಬಹುದಾದ ಪದಗಳನ್ನು ಹುಡುಕಿ


ತೊಂದರೆ ಮಟ್ಟ ಸುಲಭ
ಆಗಾಗ್ಗೆ ಕೇಳಲಾಗುತ್ತದೆ ಅಮೆಜಾನ್
ಅರೇ ಹ್ಯಾಶಿಂಗ್

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

“ಅಕ್ಷರಗಳಿಂದ ರೂಪಿಸಬಹುದಾದ ಪದಗಳನ್ನು ಹುಡುಕಿ” ಎಂಬ ಸಮಸ್ಯೆಯಲ್ಲಿ ನಮಗೆ ಲೋವರ್ ಕೇಸ್ ಇಂಗ್ಲಿಷ್ ವರ್ಣಮಾಲೆಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ತಂತಿಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ನೀಡಲಾಗಿದೆ (ಪದಗಳು) ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ ಅದು ಅಕ್ಷರಗಳ ಗುಂಪನ್ನು ಒಳಗೊಂಡಿದೆ (ಅಕ್ಷರಗಳು).

ಅಕ್ಷರಗಳ ಅಕ್ಷರಗಳನ್ನು ಬಳಸಿಕೊಂಡು ರಚನೆಯಾಗಬಹುದೇ ಎಂದು ರಚನೆಯಲ್ಲಿನ ಪ್ರತಿಯೊಂದು ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಪರಿಶೀಲಿಸುವುದು ನಮ್ಮ ಕಾರ್ಯವಾಗಿದೆ (ನಾವು ಚಾರ್‌ನ ಪ್ರತಿಯೊಂದು ಅಕ್ಷರಗಳನ್ನು ಒಮ್ಮೆ ಮಾತ್ರ ಬಳಸಬಹುದು). ಕೊನೆಯಲ್ಲಿ, ಅಕ್ಷರಗಳ ಸ್ಟ್ರಿಂಗ್‌ನ ಅಕ್ಷರಗಳನ್ನು ಬಳಸಿಕೊಂಡು ರಚಿಸಬಹುದಾದ ಎಲ್ಲಾ ತಂತಿಗಳ ಉದ್ದದ ಮೊತ್ತವನ್ನು ನಾವು ಹಿಂದಿರುಗಿಸಬೇಕಾಗಿದೆ.

ಉದಾಹರಣೆ

words = ["hello","world","tutorialcup"], chars = "welldonehoneyr"
10

ವಿವರಣೆ:

ಅಕ್ಷರಗಳ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದಿಂದ ರೂಪಿಸಬಹುದಾದ ಪದಗಳನ್ನು ಹುಡುಕಿ

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ಅಕ್ಷರಗಳ ಸ್ಟ್ರಿಂಗ್‌ನ ಅಕ್ಷರಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನಾವು ಹಲೋ ಮತ್ತು ವರ್ಲ್ಡ್ ಅನ್ನು ರಚಿಸಬಹುದು. ಆದ್ದರಿಂದ ಹಲೋ ಮತ್ತು ಪ್ರಪಂಚದ ಒಟ್ಟು ಉದ್ದ 5 + 5 = 10 ಆಗಿದೆ.

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

ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ನಾವು ಆವರ್ತನ ಶ್ರೇಣಿಯನ್ನು ಬಳಸುತ್ತೇವೆ ಮತ್ತು ಅದು ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿರುವ ಅಕ್ಷರಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ. ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ನಾವು ಈ ಹಂತಗಳನ್ನು ಅನುಸರಿಸುತ್ತೇವೆ:

  1. ಆವರ್ತನ ರಚನೆಯನ್ನು ರಚಿಸಿ ಮತ್ತು ಅಕ್ಷರಗಳ ಸ್ಟ್ರಿಂಗ್‌ನ ಅಕ್ಷರಗಳ ಆವರ್ತನವನ್ನು ಸಂಗ್ರಹಿಸಿ.
  2. ಈಗ ಪದ ರಚನೆಯ ಪ್ರತಿಯೊಂದು ದಾರವನ್ನು ಒಂದೊಂದಾಗಿ ಪರಿಶೀಲಿಸಿ.
    1. ಆವರ್ತನ ರಚನೆಯ ನಕಲನ್ನು ರಚಿಸಿ.
    2. ಈಗ ಆಯ್ದ ಸ್ಟ್ರಿಂಗ್‌ನ ಪ್ರತಿಯೊಂದು ಅಕ್ಷರವನ್ನು ಪರಿಶೀಲಿಸಿ. ಆವರ್ತನ ಶ್ರೇಣಿಯಲ್ಲಿನ ಅಕ್ಷರಗಳ ಆವರ್ತನವು 1 ಕ್ಕಿಂತ ಕಡಿಮೆಯಿದ್ದರೆ, ಅಕ್ಷರಗಳ ಸ್ಟ್ರಿಂಗ್‌ನ ಅಕ್ಷರಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನಾವು ಆಯ್ದ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ರೂಪಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ, ಇಲ್ಲದಿದ್ದರೆ ಅಕ್ಷರ ಆವರ್ತನವನ್ನು 1 ರಷ್ಟು ಕಡಿಮೆ ಮಾಡಿ.
    3. ಅಕ್ಷರಗಳ ಸ್ಟ್ರಿಂಗ್‌ನ ಅಕ್ಷರಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ಸಾಧ್ಯವಾದರೆ, ಆಯ್ದ ಸ್ಟ್ರಿಂಗ್‌ನ ಉದ್ದವನ್ನು ಫಲಿತಾಂಶಕ್ಕೆ ಸೇರಿಸಿ.
  3. ಫಲಿತಾಂಶದ ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿ.

ಅನುಷ್ಠಾನ

ಅಕ್ಷರಗಳಿಂದ ರೂಪಿಸಬಹುದಾದ ಪದಗಳನ್ನು ಹುಡುಕಲು ಸಿ ++ ಕೋಡ್

#include <bits/stdc++.h> 
using namespace std; 
int countCharacters(vector<string>& words, string chars) {
  vector<int> cnt(26);
  int res = 0;
  for (auto ch : chars) ++cnt[ch - 'a'];
  for (auto w : words) {
    vector<int> cnt1 = cnt;
    bool match = true;
    for (auto ch : w) {
      if (--cnt1[ch - 'a'] < 0) {
        match = false;
        break;
      }
    }
    if (match) res += w.size();
  }
  return res;
}

int main() 
{ 
    vector<string> words {"hello","world","tutorialcup"};
    string ch="welldonehoneyr";
    int ans=countCharacters(words,ch); 
    cout<<ans<<endl;
    return 0;
}
10

ಅಕ್ಷರಗಳಿಂದ ರೂಪಿಸಬಹುದಾದ ಪದಗಳನ್ನು ಹುಡುಕಿ ಜಾವಾ ಕೋಡ್

import java.util.Arrays;
import java.util.Set ;
import java.util.HashSet;
import java.util.*; 
public class Tutorialcup {
public static int countCharacters(String[] words, String chars) {
        int[] count = new int[26];
        int res = 0;
        
        for (char ch : chars.toCharArray()) {
            count[ch - 'a']++;
        }
        
        for (String word : words) {
            int[] temp = count.clone();
            boolean match = true;
            
            for (char ch : word.toCharArray()) {
                if (--temp[ch - 'a'] < 0) {
                    match = false;
                    break;
                }
            }
            
            if (match) {
                res += word.length();
            }
        }
        
        return res;
    }
  public static void main(String[] args) {
        String[] words={"hello","world","tutorialcup"};
        String ch="welldonehoneyr";
        int ans=countCharacters(words,ch); 
        System.out.println(ans);
  }
}
10

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

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

ಮೇಲಿನ ಕೋಡ್‌ನ ಸಮಯದ ಸಂಕೀರ್ಣತೆಯಾಗಿದೆ ಒ (ಎನ್ * ಮೀ) ಏಕೆಂದರೆ ನಾವು ಎಲ್ಲಾ ಪದಗಳ ಪ್ರತಿಯೊಂದು ಪಾತ್ರವನ್ನು ಹಾದುಹೋಗುತ್ತಿದ್ದೇವೆ. ಇಲ್ಲಿ n ಎಂಬುದು ನಿರ್ದಿಷ್ಟ ಶ್ರೇಣಿಯ ಉದ್ದವಾಗಿದೆ ಮತ್ತು m ಎಂಬುದು ನಿರ್ದಿಷ್ಟ ಶ್ರೇಣಿಯ ಸ್ಟ್ರಿಂಗ್‌ನ ಗರಿಷ್ಠ ಉದ್ದವಾಗಿದೆ.

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

ಮೇಲಿನ ಕೋಡ್‌ನ ಸ್ಥಳ ಸಂಕೀರ್ಣತೆಯಾಗಿದೆ ಒ (1) ಏಕೆಂದರೆ ನಾವು ಉತ್ತರವನ್ನು ಸಂಗ್ರಹಿಸಲು ವೇರಿಯೇಬಲ್ ಅನ್ನು ಮಾತ್ರ ಬಳಸುತ್ತಿದ್ದೇವೆ.

ಉಲ್ಲೇಖಗಳು