ಬಲಭಾಗದ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದಲ್ಲಿ ಎಲಿಮೆಂಟ್‌ಗಳನ್ನು ಗ್ರೇಟೆಸ್ಟ್ ಎಲಿಮೆಂಟ್‌ನೊಂದಿಗೆ ಬದಲಾಯಿಸಿ


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

ಎಲಿಮೆಂಟ್ಸ್ ಅನ್ನು ಗ್ರೇಟ್ ಎಲಿಮೆಂಟ್‌ನೊಂದಿಗೆ ರೈಟ್ ಸೈಡ್ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದಲ್ಲಿ ಬದಲಾಯಿಸುವ ಸಮಸ್ಯೆ ನಮಗೆ ಒಂದು ಒದಗಿಸುತ್ತದೆ ಸರಣಿ ಅಥವಾ ಪೂರ್ಣಾಂಕಗಳ ವೆಕ್ಟರ್. ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಬಲಭಾಗದಲ್ಲಿರುವ ಎಲ್ಲ ಅಂಶಗಳಲ್ಲಿ ಶ್ರೇಷ್ಠವಾದ ಅಂಶದೊಂದಿಗೆ ಬದಲಾಯಿಸಲು ಸಮಸ್ಯೆ ನಮ್ಮನ್ನು ಕೇಳಿದೆ. ಆದ್ದರಿಂದ ನಾವು a a, b, c a ಎಂಬ ಶ್ರೇಣಿಯನ್ನು ಅಥವಾ ಅನುಕ್ರಮವನ್ನು ಹೊಂದಿದ್ದರೆ ಪರಿಗಣಿಸಿ. ಸಂಖ್ಯೆಗಳು ಪ್ರವೃತ್ತಿಯನ್ನು ಅನುಸರಿಸಿದರೆ, b> c> a. ಆದ್ದರಿಂದ, ಪ್ರಶ್ನೆಯ ಪ್ರಕಾರ, output ಟ್ಪುಟ್ {b, c, -1 be ಆಗಿರಬೇಕು. ದ್ರಾವಣದಲ್ಲಿ ಆಳವಾಗಿ ಧುಮುಕುವ ಮೊದಲು, ಕೆಲವು ಉದಾಹರಣೆಗಳನ್ನು ಪರಿಶೀಲಿಸೋಣ.

ಬಲಭಾಗದ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದಲ್ಲಿ ಎಲಿಮೆಂಟ್‌ಗಳನ್ನು ಗ್ರೇಟೆಸ್ಟ್ ಎಲಿಮೆಂಟ್‌ನೊಂದಿಗೆ ಬದಲಾಯಿಸಿ

[17,18,5,4,6,1]
[18,6,6,6,1,-1]

ವಿವರಣೆ: element ಟ್‌ಪುಟ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಸುಲಭ ಏಕೆಂದರೆ ಪ್ರತಿಯೊಂದು ಅಂಶವನ್ನು ಅದರ ಬಲಭಾಗದಲ್ಲಿರುವ ದೊಡ್ಡ ಅಂಶದಿಂದ ಬದಲಾಯಿಸಲಾಗಿದೆ.

[400]
[-1]

ವಿವರಣೆ: ಪ್ರಸ್ತುತ ಸಂಖ್ಯೆಯ ಬಲಕ್ಕೆ ಯಾವುದೇ ಅಂಶವಿಲ್ಲದ ಕಾರಣ. ಹೀಗಾಗಿ ನಾವು -1 ಅನ್ನು .ಟ್‌ಪುಟ್‌ನಂತೆ ಹಿಂದಿರುಗಿಸುತ್ತೇವೆ.

ಬಲಭಾಗದ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರದಲ್ಲಿ ಎಲಿಮೆಂಟ್ಸ್ ಅನ್ನು ಗ್ರೇಟೆಸ್ಟ್ ಎಲಿಮೆಂಟ್‌ನೊಂದಿಗೆ ಬದಲಾಯಿಸುವ ವಿಧಾನ

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

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

ಸಿ ++ ಕೋಡ್

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

vector<int> replaceElements(vector<int>& arr) {
    int mx = -1, a;
    int n = arr.size();
    for (int i = n - 1; i >= 0; --i) {
        a = arr[i];
        arr[i] = mx;
        mx = max(mx, a);
    }
    return arr;
}

int main(){
    vector<int> arr = {17,18,5,4,6,1};
    vector<int> output = replaceElements(arr);
    for(int i=0;i<6;i++)
        cout<<output[i]<<" ";
}
18 6 6 6 1 -1

ಜಾವಾ ಕೋಡ್

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

class Main {
  public static int[] replaceElements(int[] arr) {
        int mx = -1, a;
        int n = arr.length;
        for (int i = n - 1; i >= 0; --i) {
            a = arr[i];
            arr[i] = mx;
            mx = Math.max(mx, a);
        }
        return arr;
    }
    
  public static void main (String[] args) throws java.lang.Exception{
    int[] arr = {17,18,5,4,6,1};
    int[] output = replaceElements(arr);
    for(int i=0;i<6;i++)
      System.out.print(output[i]+" ");
  }
}
18 6 6 6 1 -1

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

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

ಒ (ಎನ್), ನಾವು ಒಮ್ಮೆ ರಚನೆಯನ್ನು ಹಾದುಹೋಗುವುದರಿಂದ. ಸಮಯದ ಸಂಕೀರ್ಣತೆಯು ಸಹ ರೇಖೀಯವಾಗಿದೆ.

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

ಒ (1), ಅಲ್ಗಾರಿದಮ್ ಒಂದು ಸ್ಥಳದಲ್ಲಿದೆ ಮತ್ತು ಆದ್ದರಿಂದ ಸ್ಥಳದ ಸಂಕೀರ್ಣತೆಯು ಸ್ಥಿರವಾಗಿರುತ್ತದೆ.