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


ತೊಂದರೆ ಮಟ್ಟ ಸುಲಭ
ಸ್ಟ್ರಿಂಗ್

ಎರಡು ಸಮಾನ ಅಕ್ಷರಗಳ ನಡುವಿನ ಅತಿದೊಡ್ಡ ಸಬ್‌ಸ್ಟ್ರಿಂಗ್ ಸಮಸ್ಯೆ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರ, ಅತಿದೊಡ್ಡ ಸಬ್‌ಸ್ಟ್ರಿಂಗ್‌ನ ಉದ್ದವನ್ನು ಕಂಡುಹಿಡಿಯಲು ನಮ್ಮನ್ನು ಕೇಳುತ್ತದೆ. ಇಲ್ಲಿ, ಸಬ್ಸ್ಟ್ರಿಂಗ್ ಮೇಲೆ ಷರತ್ತು ವಿಧಿಸಲಾಗುತ್ತದೆ. ಸಬ್‌ಸ್ಟ್ರಿಂಗ್ ಒಂದೇ ಅಕ್ಷರಗಳ ನಡುವೆ ಇರಬೇಕು. ಆದ್ದರಿಂದ, ದಿ ಸ್ಟ್ರಿಂಗ್ ಕನಿಷ್ಟ ಎರಡು ಸಮಾನ ಅಕ್ಷರಗಳನ್ನು ಹೊಂದಿರಬೇಕು, ಇದರಿಂದಾಗಿ output ಟ್‌ಪುಟ್ ನೈಸರ್ಗಿಕ ಸಂಖ್ಯೆಯಾಗಿರುತ್ತದೆ -1 ಮರಳುತ್ತದೆ. ಆದರೆ ಪರಿಹಾರದೊಂದಿಗೆ ಮುಂದುವರಿಯುವ ಮೊದಲು ನಾವು ಕೆಲವು ಉದಾಹರಣೆಗಳನ್ನು ನೋಡೋಣ.

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

s = "aa"
0

ವಿವರಣೆ: ಇನ್ಪುಟ್ ಎರಡು 'ಎ'ಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ ಮತ್ತು ಅವುಗಳ ನಡುವಿನ ದಾರವು ಹೇರಿದ ಷರತ್ತುಗಳನ್ನು ಪೂರೈಸುವ ಉದ್ದದ ಸಬ್ಸ್ಟ್ರಿಂಗ್ ಆಗಿರುತ್ತದೆ. ಹೀಗಾಗಿ, output ಟ್ಪುಟ್ ಸರಿಯಾಗಿದೆ.

s = "abca"
2

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

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

ಸಮಸ್ಯೆಗೆ ಪರಿಹಾರ ಎರಡು ಸಮಾನ ಅಕ್ಷರಗಳ ನಡುವಿನ ದೊಡ್ಡ ಸಬ್‌ಸ್ಟ್ರಿಂಗ್ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಸುಲಭ. ಸಮಸ್ಯೆಯಲ್ಲಿ, ಅತಿದೊಡ್ಡ ಸಬ್‌ಸ್ಟ್ರಿಂಗ್‌ನ ಉದ್ದವನ್ನು ಕಂಡುಹಿಡಿಯಲು ಮಾತ್ರ ನಮ್ಮನ್ನು ಕೇಳಲಾಗುತ್ತದೆ ಆದರೆ ಸ್ಟ್ರಿಂಗ್ ಸ್ವತಃ ಅಲ್ಲ. ಆದ್ದರಿಂದ, ನಾವು ಯಾವುದೇ ಪಾತ್ರದ ಮೊದಲ ಮತ್ತು ಕೊನೆಯ ಸೂಚಿಯನ್ನು ಸಂಗ್ರಹಿಸುವ ಎರಡು ಸರಣಿಗಳನ್ನು ರಚಿಸುತ್ತೇವೆ. ಆರಂಭದಲ್ಲಿ, ನಾವು ಈ ಸರಣಿಗಳನ್ನು -1 ನೊಂದಿಗೆ ತುಂಬಿಸುತ್ತೇವೆ, ಅದು ಅಕ್ಷರಗಳ ಯಾವುದೇ ಸಂಭವವನ್ನು ಸೂಚಿಸುವುದಿಲ್ಲ. ನಾವು ಒಂದು ಅಕ್ಷರವನ್ನು ಕಂಡುಕೊಂಡ ನಂತರ ನಾವು ಸೂಚ್ಯಂಕವನ್ನು -1 ರಿಂದ ತುಂಬಿದ್ದರೆ ಅದನ್ನು ಮೊದಲ ಶ್ರೇಣಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತೇವೆ. ಅದು -1 ಅನ್ನು ಹೊಂದಿಲ್ಲದಿದ್ದರೆ, ನಾವು ಸೂಚ್ಯಂಕವನ್ನು ಎರಡನೇ ಶ್ರೇಣಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತೇವೆ.

ಈ ಎರಡು ಸರಣಿಗಳನ್ನು ಬಳಸಿ, ನಾವು ಗರಿಷ್ಠ ಉದ್ದವನ್ನು ಕಂಡುಕೊಳ್ಳುತ್ತೇವೆ. ಎರಡೂ ಸರಣಿಗಳ ಎಲ್ಲಾ ಸೂಚ್ಯಂಕಗಳನ್ನು ಪರಿಶೀಲಿಸುವ ನಾವು 0 ರಿಂದ 25 ರವರೆಗೆ ಲೂಪ್ ಅನ್ನು ಚಾಲನೆ ಮಾಡುತ್ತೇವೆ. ಸೂಚ್ಯಂಕಗಳು ಮಾನ್ಯವಾಗಿದ್ದರೆ ನಾವು ಪ್ರತಿ ಪುನರಾವರ್ತನೆಯಲ್ಲೂ ಉತ್ತರವನ್ನು ನವೀಕರಿಸುತ್ತೇವೆ. ಕೊನೆಯಲ್ಲಿ, ನಾವು ಉತ್ತರವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತೇವೆ.

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

ಸಿ ++ ಕೋಡ್

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

int maxLengthBetweenEqualCharacters(string s) {
    vector<int> f1(26, -1), f2(26, -1);
    int n = s.size();
    for(int i=0;i<n;i++){
        if(f1[s[i]-'a'] == -1)
            f1[s[i]-'a'] = i;
        else
            f2[s[i]-'a'] = i;
    }

    int ans = -1;
    for(int i=0;i<26;i++)
        if(f2[i] != -1)
            ans = max(ans, f2[i]-f1[i]-1);
    return ans;
}

int main(){
    cout<<maxLengthBetweenEqualCharacters("aa");
}
0

ಜಾವಾ ಕೋಡ್

import java.util.*;
import java.lang.*;
import java.io.*;

class Main
{
  public static int maxLengthBetweenEqualCharacters(String s) {
        int[] f1 = new int[26];
        int[] f2 = new int[26];
        for(int i=0;i<26;i++){
            f1[i] = -1;
            f2[i] = -1;
        }
        int n = s.length();
        for(int i=0;i<n;i++){
            if(f1[s.charAt(i)-'a'] == -1)
                f1[s.charAt(i)-'a'] = i;
            else
                f2[s.charAt(i)-'a'] = i;
        }
        
        int ans = -1;
        for(int i=0;i<26;i++)
            if(f2[i] != -1)
                ans = Math.max(ans, f2[i]-f1[i]-1);
        return ans;
    }
    
  public static void main (String[] args) throws java.lang.Exception
  {
    String s = "aa";
    System.out.print(maxLengthBetweenEqualCharacters(s));
  }
}
0

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

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

ಒ (ಎನ್), ಏಕೆಂದರೆ ಸಂಪೂರ್ಣ ಇನ್ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹಾದುಹೋಗಿರಿ.

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

ಒ (1), ಏಕೆಂದರೆ ನಾವು ಸ್ಥಿರ ಗಾತ್ರದ ಸರಣಿಗಳನ್ನು ಬಳಸಿದ್ದೇವೆ.