ವ್ಯತ್ಯಾಸ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರವನ್ನು ಹುಡುಕಿ


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

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

“ವ್ಯತ್ಯಾಸವನ್ನು ಕಂಡುಕೊಳ್ಳಿ” ಸಮಸ್ಯೆಯಲ್ಲಿ ನಮಗೆ ಎರಡು ನೀಡಲಾಗಿದೆ ತಂತಿಗಳು ರು ಮತ್ತು ಟಿ. ಸ್ಟ್ರಿಂಗ್ ಟಿ ಯ ಅಕ್ಷರಗಳನ್ನು ಯಾದೃಚ್ ly ಿಕವಾಗಿ ತುಂಬಿಸಿ ಮತ್ತು ಯಾದೃಚ್ position ಿಕ ಸ್ಥಾನದಲ್ಲಿ ಒಂದು ಅಕ್ಷರವನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ಸ್ಟ್ರಿಂಗ್ ಟಿ ಅನ್ನು ಉತ್ಪಾದಿಸಲಾಗುತ್ತದೆ.

ಸ್ಟ್ರಿಂಗ್ ಟಿ ನಲ್ಲಿ ಸೇರಿಸಲಾದ ಅಕ್ಷರವನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ನಮ್ಮ ಕಾರ್ಯ.

ಉದಾಹರಣೆ

s = "abcd", t = "abcde"
e

ವಿವರಣೆ:

ವ್ಯತ್ಯಾಸ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರವನ್ನು ಹುಡುಕಿ

ಸ್ಟ್ರಿಂಗ್ ಟಿ ಅಕ್ಷರಗಳನ್ನು ಮರುಹೊಂದಿಸಿದ ನಂತರ ಅದು “ಎಬಿಸಿಡಿ” ಆಗುತ್ತದೆ. “ಎಬಿಸಿಡಿ” ಈಗಾಗಲೇ ಸ್ಟ್ರಿಂಗ್‌ಗಳಲ್ಲಿ ಇರುವುದರಿಂದ, ಟಿ ಗೆ ಸೇರಿಸಲಾದ ಅಕ್ಷರವು “ಇ” ಆಗಿದೆ.

ವ್ಯತ್ಯಾಸ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರವನ್ನು ಕಂಡುಹಿಡಿಯಲು ಅಪ್ರೋಚ್ ಅನ್ನು ವಿಂಗಡಿಸುವುದು

ಸಮಸ್ಯೆಯನ್ನು ನೋಡಲು ನಾವು ನಮ್ಮ ದೃಷ್ಟಿಕೋನವನ್ನು ಬದಲಾಯಿಸಿದರೆ ಕೆಲವೊಮ್ಮೆ ಅದನ್ನು ಪರಿಹರಿಸುವುದು ಸುಲಭವಾಗುತ್ತದೆ. ಇಲ್ಲಿರುವಂತೆ ಸ್ಟ್ರಿಂಗ್ ಟಿ ಅನ್ನು ಸ್ಟ್ರಿಂಗ್ ಗಳನ್ನು ಬದಲಾಯಿಸುವ ಮೂಲಕ ಮತ್ತು ಒಂದು ಅಂಶವನ್ನು ಯಾದೃಚ್ position ಿಕ ಸ್ಥಾನದಲ್ಲಿ ಸೇರಿಸುವ ಮೂಲಕ ಉತ್ಪತ್ತಿಯಾಗುತ್ತದೆ ಎಂದು ಸಮಸ್ಯೆ ಹೇಳುತ್ತದೆ. ಆದ್ದರಿಂದ, ಸ್ಟ್ರಿಂಗ್ s ನಲ್ಲಿ ಯಾದೃಚ್ position ಿಕ ಸ್ಥಾನದಲ್ಲಿ ಅಕ್ಷರವನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ಸ್ಟ್ರಿಂಗ್ ಟಿ ಉತ್ಪತ್ತಿಯಾಗುವುದರಿಂದ ನಾವು ಇದನ್ನು ನೋಡಬಹುದು. ಈಗ ನಾವು ಸ್ಟ್ರಿಂಗ್ s ನ ಅಕ್ಷರವು ಸ್ಟ್ರಿಂಗ್ ಟಿ ಪಾತ್ರದೊಂದಿಗೆ ಹೊಂದಿಕೆಯಾಗದ ಸ್ಥಾನವನ್ನು ಮಾತ್ರ ಕಂಡುಹಿಡಿಯಬೇಕು ಮತ್ತು ನಂತರ ನಾವು ಆ ಸ್ಥಾನದಲ್ಲಿರುವ ಅಕ್ಷರವನ್ನು ಹಿಂತಿರುಗಿಸಬಹುದು. ಆದ್ದರಿಂದ ನಾವು ಈ ಹಂತಗಳನ್ನು ಅನುಸರಿಸುತ್ತೇವೆ:

  1. ಎರಡೂ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ವಿಂಗಡಿಸಿ.
  2. ಅಕ್ಷರದಿಂದ ಅಕ್ಷರವನ್ನು ಪರಿಶೀಲಿಸಿ ಸ್ಟ್ರಿಂಗ್ ಮತ್ತು ಅವು ಹೊಂದಿಕೆಯಾಗದ ಬಿಂದುವು ಸೇರಿಸಿದ ಅಕ್ಷರವಾಗಿದೆ ಮತ್ತು ಅದು ಉತ್ತರವಾಗಿದೆ.
  3. ಎಲ್ಲಾ ಅಕ್ಷರಗಳು ಹೊಂದಿಕೆಯಾದರೆ, ಸ್ಟ್ರಿಂಗ್ ಟಿ ಯ ಕೊನೆಯ ಸ್ಥಾನದಲ್ಲಿರುವ ಅಕ್ಷರ ನಮ್ಮ ಉತ್ತರವಾಗಿದೆ.

ಅನುಷ್ಠಾನ

ಫೈಂಡ್ ದಿ ಡಿಫರೆನ್ಸ್‌ಗಾಗಿ ಸಿ ++ ಕೋಡ್

#include <bits/stdc++.h> 
using namespace std; 
    char findTheDifference(string s, string t) {
        sort(s.begin(),s.end());
    
    sort(t.begin(),t.end());
    
    
    for(int i=0;i<s.length();i++)
    {
      if(s[i]!=t[i])
      {
        return t[i];
      }
    }
    
    return t[t.length()-1];
    }

int main() 
{ 
 string s="abcd",t="abcde";
 char ans=findTheDifference(s,t);
 cout<<ans<<endl;
 return 0;
}
e

ಫೈಂಡ್ ದಿ ಡಿಫರೆನ್ಸ್‌ಗಾಗಿ ಜಾವಾ ಕೋಡ್

import java.util.Arrays;
import java.util.Set ;
import java.util.HashSet;
import java.util.*; 
public class Tutorialcup {
    public static char findTheDifference(String s, String t) {
    char[] sortedS = s.toCharArray();
    char[] sortedT = t.toCharArray();
    Arrays.sort(sortedS);
    Arrays.sort(sortedT);
    for(int i=0;i<s.length();i++){
      if (sortedS[i] != sortedT[i]) {
        return sortedT[i];
      }
    }

    return sortedT[s.length()];
    }
  public static void main(String[] args) {
     String s="abcd",t="abcde";
     char ans=findTheDifference(s,t);
        System.out.println(ans);
  }
}
e

ವ್ಯತ್ಯಾಸವನ್ನು ಕಂಡುಕೊಳ್ಳುವ ಸಂಕೀರ್ಣತೆ ವಿಶ್ಲೇಷಣೆ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರ

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

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

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

ಮೇಲಿನ ಕೋಡ್‌ನ ಸ್ಥಳ ಸಂಕೀರ್ಣತೆಯಾಗಿದೆ ಓ (ಎನ್) ಜಾವಾ ಪರಿಹಾರಕ್ಕಾಗಿ ನಾವು ತಂತಿಗಳನ್ನು ರಚನೆಯಾಗಿ ಪರಿವರ್ತಿಸುತ್ತಿದ್ದೇವೆ ಆದರೆ ಸಿ ++ ಗೆ ಇದು ಒ (1) ಏಕೆಂದರೆ ಅದು ಕುಟುಕು ಸ್ಥಳದಲ್ಲಿಯೇ ವಿಂಗಡಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ವ್ಯತ್ಯಾಸ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರವನ್ನು ಕಂಡುಹಿಡಿಯಲು ಹ್ಯಾಶಿಂಗ್ ಅಪ್ರೋಚ್

ನಾವು ಈ ಹಂತಗಳನ್ನು ಅನುಸರಿಸುತ್ತೇವೆ:

  1. ಅಕ್ಷರಗಳ ಆವರ್ತನವನ್ನು ಸಂಗ್ರಹಿಸಲು ಗಾತ್ರ 26 ರ ಆವರ್ತನ ಶ್ರೇಣಿಯನ್ನು ರಚಿಸಿ. ನಾವು ಅದನ್ನು 0 ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ.
  2. ಸ್ಟ್ರಿಂಗ್ ಗಳನ್ನು ಹಾದುಹೋಗಿರಿ ಮತ್ತು ಆವರ್ತನ ಶ್ರೇಣಿಯಲ್ಲಿ ಅಕ್ಷರಗಳ ಆವರ್ತನವನ್ನು ಸಂಗ್ರಹಿಸಿ.
  3. ಈಗ ಸ್ಟ್ರಿಂಗ್ ಟಿ ಅನ್ನು ಹಾದುಹೋಗಿರಿ ಮತ್ತು ಆವರ್ತನ ರಚನೆಯಿಂದ ಸ್ಟ್ರಿಂಗ್ ಟಿ ಯ ಅಡ್ಡಾದಿಡ್ಡಿಯ ಸಮಯದಲ್ಲಿ ನೀವು ಎದುರಿಸುವ ಪ್ರತಿಯೊಂದು ಪಾತ್ರದ ಆವರ್ತನವನ್ನು ಕಡಿಮೆ ಮಾಡಿ.
  4. ಕೊನೆಯಲ್ಲಿ, ಆವರ್ತನ ಶ್ರೇಣಿಯನ್ನು ಹಾದುಹೋಗಿರಿ ಮತ್ತು ಮೌಲ್ಯದೊಂದಿಗೆ ಸ್ಥಾನಕ್ಕೆ ಅನುಗುಣವಾದ ಅಕ್ಷರವು ಸೇರಿಸಿದ ಅಕ್ಷರವಾಗಿದೆ ಮತ್ತು ಅದು ಅಗತ್ಯವಾದ ಉತ್ತರವಾಗಿದೆ.

ಅನುಷ್ಠಾನ

ಫೈಂಡ್ ದಿ ಡಿಫರೆನ್ಸ್‌ಗಾಗಿ ಸಿ ++ ಕೋಡ್

#include <bits/stdc++.h> 
using namespace std; 
      char findTheDifference(string s, string t) {
        int count[26] = {0};
        for(int i=0;i<s.length();i++) count[s[i]-'a']++;
        for(int i=0;i<t.length();i++) count[t[i]-'a']--;
        for(int i=0;i<26;i++) if(count[i] !=0) return (char)(i+'a');
        return 'a';
    }

int main() 
{ 
 string s="abcd",t="abcde";
 char ans=findTheDifference(s,t);
 cout<<ans<<endl;
 return 0;
}
e

ಫೈಂಡ್ ದಿ ಡಿಫರೆನ್ಸ್‌ಗಾಗಿ ಜಾವಾ ಕೋಡ್

import java.util.Arrays;
import java.util.Set ;
import java.util.HashSet;
import java.util.*; 
public class Tutorialcup {
    public static char findTheDifference(String s, String t) {
        int[] count = new int[26];
        char[] S = s.toCharArray(), T = t.toCharArray();
        for(int i=0;i<S.length;i++) count[S[i]-'a']++;
        for(int i=0;i<T.length;i++) count[T[i]-'a']--;
        for(int i=0;i<26;i++) if(count[i] !=0) return (char)(i+'a');
        return '\0';
    }
  public static void main(String[] args) {
     String s="abcd",t="abcde";
     char ans=findTheDifference(s,t);
        System.out.println(ans);
  }
}
e

ವ್ಯತ್ಯಾಸವನ್ನು ಕಂಡುಕೊಳ್ಳುವ ಸಂಕೀರ್ಣತೆ ವಿಶ್ಲೇಷಣೆ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರ

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

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

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

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

ಉಲ್ಲೇಖಗಳು