एलिमेन्टहरू बदल्नुहोस् सबैभन्दा ठूलो एलिमेन्टको साथ दायाँ साइड Leetcode समाधान


कठिनाई तह सजिलो
बारम्बार सोधिन्छ अमेजन
एरे

समस्या एलिमेन्ट्स बदल्नुहोस् सबैभन्दा ठूलो एलिमेन्टको साथ दायाँ साइड Leetcode समाधानले हामीलाई प्रदान गर्दछ array वा पूर्णांकको भेक्टर समस्याले हामीलाई सबै तत्वहरू एलिमेन्टको साथ प्रतिस्थापन गर्न सोध्यो जुन सबै पक्षहरूमा दायाँपट्टि सब भन्दा ठूलो हो। त्यसोभए विचार गर्नुहोस् यदि हामीसँग एर्रे वा अनुक्रम छ, {a, b, c}। यदि नम्बरहरूले ट्रेंड अनुसरण गर्दछ भने, b> c> a त्यसो भए प्रश्नको आधारमा आउटपुट {b, c, -1} हुनु पर्छ। समाधानमा गहिरो डाइभ गर्नु अघि हामी केही उदाहरणहरू जाँचौं।

एलिमेन्टहरू बदल्नुहोस् सबैभन्दा ठूलो एलिमेन्टको साथ दायाँ साइड Leetcode समाधान

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

स्पष्टीकरण: आउटपुट बुझ्नको लागि सजिलो छ किनकि प्रत्येक तत्व यसको दायाँपट्टि सब भन्दा ठूलो तत्त्वद्वारा प्रतिस्थापन गरिएको छ।

[400]
[-1]

स्पष्टीकरण: किनकि वर्तमान संख्याको दायाँमा कुनै तत्व छैन। त्यसैले हामी आउटपुट को रूपमा -१ फर्काउँछौं।

दायाँ साइड Leetcode समाधानमा महान एलिमेन्टको साथ एलिमेन्टहरू बदल्नुहोस्को लागि दृष्टिकोण

समस्याले समस्या स्पष्ट रूपमा यसको नामबाट बताउँछ। समस्याले भन्छ कि प्रत्येक तत्वलाई ठूला तत्वसँग प्रतिस्थापन गर्न जुन यसको दाहिने तिर देखा पर्दछ। अब, मात्र के गर्न बाँकी छ प्रक्रिया सिमुलेट गर्न। हामी सजिलै यो गर्न सक्दछौं यदि हामी दायाँ बाट एर्रे ट्र्याभर्सिंग गर्न शुरू गर्दछौं। त्यसोभए, बायाँ तर्फ जानुको सट्टा हामी दाहिने तर्फबाट सुरु गर्दछौं। हामी एक एलिमेन्ट राख्छौं जुन अब सम्म पाइएको अधिकतम तत्व भण्डार गर्दछ। हामी हालको एलिमेन्ट भ्यारीएबलमा भण्डार गर्छौं, तब अधिकतम मान अपडेट गर्न जारी राख्छौं। यस बिन्दुमा, हामी हालको एलिमेन्टलाई सब भन्दा ठूलो तत्व / अधिकतम तत्वसँग बदल्न सक्दछौं।

कोड दायाँ साइड Leetcode समाधान मा महान एलिमेन्ट संग प्रतिस्थापन गर्न को लागी कोड

C ++ कोड

#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

जटिलता विश्लेषण

समय जटिलता

O (N), किनकि हामी एक पटक एर्रे पार गर्दछौं। समय जटिलता पनि रैखिक छ।

ठाउँ जटिलता

O (१), एल्गोरिथ्म एक ठाउँमा एक हो र यसैले ठाउँ जटिलता स्थिर छ।