ஸ்டேக் ஆபரேஷன்ஸ் லீட்கோட் தீர்வுடன் ஒரு வரிசையை உருவாக்குங்கள்


சிரமம் நிலை எளிதாக
அடிக்கடி கேட்கப்படுகிறது கூகிள்
ஸ்டேக்

ஸ்டேக் ஆபரேஷன்களுடன் ஒரு வரிசையை உருவாக்குதல் லீட்கோட் தீர்வு சிக்கல் எங்களுக்கு ஒரு வழங்குகிறது முழு வரிசை மற்றும் ஒரு முழு எண் n. 1 முதல் n வரையிலான முழு எண்களின் வரிசை நமக்கு வழங்கப்படுகிறது என்று சிக்கல் கூறுகிறது. உள்ளீடாக எங்களுக்கு வழங்கப்பட்ட ஒரு முழு வரிசை வரிசையை உருவாக்க ஒரு அடுக்கைப் பயன்படுத்துகிறோம். கொடுக்கப்பட்ட வரிசையைப் பெற “புஷ்” மற்றும் “பாப்” செயல்பாடுகளை மட்டுமே பயன்படுத்த முடியும். எனவே, தீர்வுடன் முன்னேறுவதற்கு முன் சில எடுத்துக்காட்டுகளைப் பார்ப்போம்.

ஸ்டேக் ஆபரேஷன்ஸ் லீட்கோட் தீர்வுடன் ஒரு வரிசையை உருவாக்குங்கள்

target = [1,3], n = 3
["Push","Push","Pop","Push"]

விளக்கம்: வெளியீட்டில் கொடுக்கப்பட்ட செயல்பாடுகள் 1 முதல் n (= 3) வரையிலான வரிசையில் சரிபார்க்கப்படலாம். முதலில், முதல் முழு எண்ணை (= 1) அடுக்கிற்கு தள்ளுகிறோம். முழு எண்ணை (= 2) புறக்கணிக்க முடியாது என்பதால், முதலில் அதை அடுக்கிற்குள் தள்ளி, பின்னர் அதை பாப் செய்கிறோம். ஏனெனில் முழு எண் 2 வெளியீட்டு வரிசையில் இல்லை. முடிவில், மூன்றாவது முழு எண்ணை (= 3) அடுக்கில் தள்ளுகிறோம். இதனால் தேவையான வெளியீடு பெறப்படுகிறது.

target = [1,2,3], n = 3
["Push","Push","Push"]

விளக்கம்: அடுக்கில் 1 முதல் n வரையிலான வரிசையில் இருந்து அனைத்து முழு எண்களும் எங்களிடம் இருப்பதால். எல்லா முழு எண்களையும் அடுக்கில் தள்ளுகிறோம். இதனால் எங்களுக்கு 3 "புஷ்" செயல்பாடுகள் வெளியீடாக உள்ளன.

ஸ்டேக் ஆபரேஷன்ஸ் லீட்கோட் தீர்வுடன் ஒரு வரிசையை உருவாக்குவதற்கான அணுகுமுறை

சிக்கல் ஸ்டாக் ஆபரேஷன்ஸ் லீட்கோட் சொல்யூஷனுடன் ஒரு வரிசையை உருவாக்குதல், முன்னர் கூறியது போல, தேவையான வெளியீட்டை உருவாக்க ஒரு ஸ்டேக் செயல்பட வேண்டிய செயல்பாடுகளை வெளியிடுவதற்கு எங்களிடம் கேட்டது. கேள்வி முற்றிலும் தற்காலிகமானது. மேலும் எப்படியாவது ஸ்டாக் செயல்பாடுகளைக் கண்டறியக்கூடிய ஒரு வழிமுறையை உருவாக்க வேண்டும்.

சிக்கலைத் தீர்ப்பதற்கு, 1 உடன் துவக்கப்பட்ட "should_ve" என்ற மாறி ஒன்றை உருவாக்குகிறோம். பின்னர் 1 க்குத் தொடங்கி 1 முதல் n வரையிலான வரிசையில் பயணிக்கும் செயல்முறையைத் தூண்டுகிறது. வெளியீட்டு வரிசையில் அவற்றின் இடத்தைக் கண்டுபிடிக்காத உறுப்புகளுக்கான புஷ் மற்றும் பாப் செயல்பாடுகளைக் கண்காணிக்க நாம் should_ve என்ற மாறினை வைத்திருக்கிறோம். எனவே, வழிமுறையைச் சுருக்கமாகச் சொல்ல, ஒவ்வொரு உறுப்புகளையும் நாம் தள்ளுகிறோம், ஆனால் நமக்குத் தேவையில்லாத கூறுகளை வெறுமனே பாப் செய்கிறோம்.

ஸ்டேக் ஆபரேஷன்ஸ் லீட்கோட் தீர்வுடன் ஒரு வரிசையை உருவாக்குவதற்கான குறியீடு

சி ++ குறியீடு

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

vector<string> buildArray(vector<int>& target, int n) {
    vector<string> output;
    int should_ve = 1;
    for(int i=1;i<=target.size();i++){
        if(target[i-1] != should_ve){
            int cnt = target[i-1]-should_ve;
            while(cnt--)
                output.push_back("Push"), output.push_back("Pop");
        }
        output.push_back("Push");
        should_ve = target[i-1] + 1;
    }

    return output;
}

int main(){
    vector<int> target = {1, 3};
    int n = 3;
    vector<string> output = buildArray(target, n);
    for(auto x: output)
        cout<<x<<" ";
}
Push Push Pop Push

ஜாவா குறியீடு

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

class Main
{
  public static List<String> buildArray(int[] target, int n) {
        List<String> output = new ArrayList<String>();
        int should_ve = 1;
        for(int i=1;i<=target.length;i++){
            if(target[i-1] != should_ve){
                int cnt = target[i-1] - should_ve;
                while(cnt-- > 0){
                    output.add("Push");
                    output.add("Pop");
                }
            }
            output.add("Push");
            should_ve = target[i-1] + 1;
        }
        
        return output;
    }
    
  public static void main (String[] args) throws java.lang.Exception
  {
    int[] target = {1, 3};
    int n = 3;
    List<String> output = buildArray(target, n);
    for(String x: output)
      System.out.print(x+" ");
  }
}
Push Push Pop Push

சிக்கலான பகுப்பாய்வு

நேர சிக்கலானது

ஓ (என்), 1 முதல் n வரையிலான ஒவ்வொரு உறுப்புகளையும் நாம் கடந்து செல்வதால். இதனால் நேர சிக்கலானது நேரியல்.

விண்வெளி சிக்கலானது

ஓ (என்), ஏனெனில் வெளியீட்டை சேமிக்க ஒரு இடைநிலை திசையன் / வரிசையைப் பயன்படுத்த வேண்டும்.