ಸ್ಟ್ರಿಂಗ್ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರವನ್ನು ಷಫಲ್ ಮಾಡಿ


ತೊಂದರೆ ಮಟ್ಟ ಸುಲಭ
ಆಗಾಗ್ಗೆ ಕೇಳಲಾಗುತ್ತದೆ ಫೇಸ್ಬುಕ್
ವಿಂಗಡಿಸಲಾಗುತ್ತಿದೆ

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

"ಷಫಲ್ ಸ್ಟ್ರಿಂಗ್" ಸಮಸ್ಯೆಯಲ್ಲಿ ನಮಗೆ ನೀಡಲಾಗಿದೆ ಸ್ಟ್ರಿಂಗ್ ಮತ್ತು ಒಂದು ಶ್ರೇಣಿ. ರಚನೆಯು ಸ್ಟ್ರಿಂಗ್‌ನ ಪಾತ್ರದ ಹೊಸ ಸೂಚ್ಯಂಕಗಳನ್ನು ಒಳಗೊಂಡಿದೆ. ಆದ್ದರಿಂದ ರಚನೆಯು [i] ಸ್ಟ್ರಿಂಗ್‌ನ ith ಸ್ಥಾನದಲ್ಲಿ ಅಕ್ಷರಗಳ ಹೊಸ ಸ್ಥಾನವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.

“ಷಫಲ್ ಸ್ಟ್ರಿಂಗ್” ನಲ್ಲಿ ನಾವು ಸ್ಟ್ರಿಂಗ್‌ನ ಅಕ್ಷರಗಳನ್ನು ಷಫಲ್ ಮಾಡುವ ರೀತಿಯಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್‌ನ ಐತ್ ಅಕ್ಷರವನ್ನು ಸೂಚ್ಯಂಕಗಳಿಗೆ [i] ನೇ ಸ್ಥಾನಕ್ಕೆ ಸರಿಸಲಾಗುವುದು ಮತ್ತು ಹೊಸ ಷಫಲ್ಡ್ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸಬೇಕು.

ಉದಾಹರಣೆ

s = "art", indices = [1,0,2]
rat

ವಿವರಣೆ:

ಅಕ್ಷರಗಳ ಹೊಸ ಸ್ಥಾನ ಹೀಗಿದೆ:

a-> 1

r-> 0

t-> 2

ಆದ್ದರಿಂದ ಅಕ್ಷರಗಳನ್ನು ಬದಲಾಯಿಸಿದ ನಂತರ ಕಲೆ ಹಾಕಿದ ಸ್ಟ್ರಿಂಗ್ ಇಲಿ.

ಷಫಲ್ ಸ್ಟ್ರಿಂಗ್ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರಕ್ಕಾಗಿ ಅನುಸಂಧಾನ

“ಷಫಲ್ ಸ್ಟ್ರಿಂಗ್” ಸಮಸ್ಯೆ ಮೂಲತಃ ಅನುಷ್ಠಾನದ ಸಮಸ್ಯೆಯಾಗಿದ್ದು, ಅಲ್ಲಿ ನಾವು ಅನುಷ್ಠಾನದ ಭಾಗಕ್ಕೆ ಹೆಚ್ಚು ಗಮನ ಹರಿಸಬೇಕಾಗಿದೆ. ಇಲ್ಲಿ ನಾವು ith ಸ್ಥಾನದಲ್ಲಿರುವ ಒಂದು ಅಕ್ಷರವನ್ನು ಸೂಚ್ಯಂಕಗಳಿಗೆ [i] ನೇ ಸ್ಥಾನಕ್ಕೆ ನಿಯೋಜಿಸಬೇಕಾಗಿದೆ. ಕೆಳಗಿನ ಚಿತ್ರದಿಂದ ಇದು ಹೆಚ್ಚು ಸ್ಪಷ್ಟವಾಗುತ್ತದೆ.

ಷಫಲ್ ಸ್ಟ್ರಿಂಗ್‌ಗೆ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರ

ಚಿತ್ರದಲ್ಲಿ ತೋರಿಸಿರುವಂತೆ “ಎ” ಅನ್ನು ಸೂಚ್ಯಂಕ ಸಂಖ್ಯೆ 1 ಕ್ಕೆ ಸರಿಸಲಾಗಿದೆ, “ಆರ್” ಅನ್ನು ಸೂಚ್ಯಂಕ ಸಂಖ್ಯೆ 0 ಕ್ಕೆ ಸರಿಸಲಾಗುತ್ತದೆ, ಮತ್ತು “ಟಿ” ಅನ್ನು ಸೂಚ್ಯಂಕ ಸಂಖ್ಯೆ 2 ಕ್ಕೆ ಸರಿಸಲಾಗುತ್ತದೆ. ಆದ್ದರಿಂದ ಷಫಲ್ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಮಾಡಿದ ನಂತರ ಅಂತಿಮ ದಾರವು “ಇಲಿ” ಆಗುತ್ತದೆ ”.

ಆದ್ದರಿಂದ ಫಲಿತಾಂಶವನ್ನು ಸಂಗ್ರಹಿಸಲು ಮತ್ತು ಅದನ್ನು ಮೂಲ ಸ್ಟ್ರಿಂಗ್‌ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಲು ನಾವು ಹೊಸ ಸ್ಟ್ರಿಂಗ್ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ. ಅದನ್ನು ಕರೆಯೋಣ ಫಲಿತಾಂಶ ಸ್ಟ್ರಿಂಗ್. ಈಗ ನಾವು ಸೂಚ್ಯಂಕಗಳ ಶ್ರೇಣಿಯನ್ನು ಹಾದುಹೋಗುತ್ತೇವೆ ಮತ್ತು ಫಲಿತಾಂಶವನ್ನು [ಸೂಚ್ಯಂಕಗಳು [i]] ಗೆ ith ಸ್ಥಾನದಲ್ಲಿ ಅಕ್ಷರವನ್ನು ನಿಯೋಜಿಸುತ್ತೇವೆ.

ಕೊನೆಯಲ್ಲಿ, ಫಲಿತಾಂಶದ ಸ್ಟ್ರಿಂಗ್ ಹೊಸ ಕಲೆಸಿದ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹೊಂದಿರುತ್ತದೆ.

ಅನುಷ್ಠಾನ

ಷಫಲ್ ಸ್ಟ್ರಿಂಗ್‌ಗಾಗಿ ಸಿ ++ ಕೋಡ್

#include <bits/stdc++.h> 
using namespace std; 
     string restoreString(string s, vector<int>& indices) {
        string res = s;
        for(int i =0; i < indices.size(); ++i)
            res[indices[i]] = s[i];
        return res;
    }
int main() 
{ 
 string s="art";      
 vector<int> arr = { 1,0,2 }; 
 cout<<restoreString(s,arr)<<endl; 
 return 0;
}
rat

ಷಫಲ್ ಸ್ಟ್ರಿಂಗ್‌ಗಾಗಿ ಜಾವಾ ಕೋಡ್

import java.util.Arrays; 
public class Tutorialcup {
    public static  String restoreString(String s, int[] indices) {
        StringBuilder res = new StringBuilder(s);
        for(int i =0; i < indices.length; ++i)
             res.setCharAt(indices[i],s.charAt(i));
        return res.toString();
    }
  public static void main(String[] args) {
    String s="art";  
    int [] arr = {1,0,2}; 
    String ans=  restoreString(s,arr);
    System.out.println(ans);
  }
}
rat

ಷಫಲ್ ಸ್ಟ್ರಿಂಗ್ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದ ಸಂಕೀರ್ಣತೆ ವಿಶ್ಲೇಷಣೆ

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

ಮೇಲಿನ ಕೋಡ್‌ನ ಸಮಯದ ಸಂಕೀರ್ಣತೆಯಾಗಿದೆ ಓ (ಎನ್) ಏಕೆಂದರೆ ನಾವು ಸೂಚ್ಯಂಕಗಳನ್ನು ಒಮ್ಮೆ ಮಾತ್ರ ಹಾದುಹೋಗುತ್ತಿದ್ದೇವೆ. ಇಲ್ಲಿ n ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿನ ಅಕ್ಷರಗಳ ಸಂಖ್ಯೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.

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

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

ಉಲ್ಲೇಖಗಳು