સ્ટેક Opeપરેશન્સ લીટકોડ સોલ્યુશન સાથે એરે બનાવો


મુશ્કેલી સ્તર સરળ
વારંવાર પૂછવામાં આવે છે Google
સ્ટેક

સ્ટેક rationsપરેશંસ સાથેનો એરે બિલ્ડ લેટકોડ સોલ્યુશન સમસ્યા અમને એક પ્રદાન કરે છે પૂર્ણાંક ક્રમ અને પૂર્ણાંક એન. સમસ્યા જણાવે છે કે આપણને 1 થી n સુધી પૂર્ણાંકોનો ક્રમ આપવામાં આવે છે. પછી આપણે પૂર્ણાંક અનુક્રમ પેદા કરવા માટે સ્ટેકનો ઉપયોગ કરીએ છીએ જે અમને ઇનપુટ તરીકે આપવામાં આવે છે. આપેલ ક્રમ મેળવવા માટે અમે ફક્ત "પુશ" અને "પ Popપ" ઓપરેશંસનો ઉપયોગ કરી શકીએ છીએ. તો ચાલો, ઉકેલમાં આગળ વધતા પહેલા થોડા ઉદાહરણો જોઈએ.

સ્ટેક Opeપરેશન્સ લીટકોડ સોલ્યુશન સાથે એરે બનાવો

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

સમજૂતી: આઉટપુટમાં આપેલ કામગીરી 1 થી n (= 3) ના ક્રમ પર ચકાસી શકાય છે. પ્રથમ, અમે સ્ટેક પર પ્રથમ પૂર્ણાંક (= 1) ને દબાણ કરીએ છીએ. પછી આપણે પૂર્ણાંક (= 2) ને અવગણી શકતા નથી, તેથી આપણે પહેલા તેને સ્ટેકમાં મૂકીએ, પછી તેને પ popપ કરો. કારણ કે પૂર્ણાંક 2 આઉટપુટ ક્રમમાં નથી. અંતમાં, અમે ત્રીજા પૂર્ણાંક (= 3) ને સ્ટેક માં દબાણ કરીએ છીએ. આમ જરૂરી આઉટપુટ પ્રાપ્ત થાય છે.

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

સમજૂતી: આપણે સ્ટેકમાં 1 થી n ની આપેલ ક્રમથી તમામ પૂર્ણાંકો આપ્યા છે. અમે બધા પૂર્ણાંકો સ્ટેકમાં ધકેલીએ છીએ. આ રીતે આઉટપુટ તરીકે આપણી પાસે 3 “પુશ” કામગીરી છે.

સ્ટેક rationsપરેશંસ લીટકોડ સોલ્યુશન સાથે એરે બનાવવા માટેનો અભિગમ

સમસ્યા સ્ટેક Leપરેશંસ સાથેનો એરે બનાવો લેટકોડ સોલ્યુશન, જેમ અગાઉ કહ્યું છે તે કામગીરીને આઉટપુટ કરવાનું કહ્યું છે કે સ્ટેક જરૂરી આઉટપુટ પેદા કરવા માટે કાર્ય કરે છે. પ્રશ્ન સંપૂર્ણ રીતે અદ્યતન છે. અને અમને કોઈ અલ્ગોરિધમનો ઘડવાની જરૂર છે જે કોઈક રીતે સ્ટેક findપરેશન શોધી શકે.

સમસ્યા હલ કરવા માટે, આપણે વેરીએબલ "should_ve" બનાવીએ છીએ જે 1 થી પ્રારંભ થયેલ છે. પછી આપણે લૂપ માટે આગળ વધીએ જે 1 થી શરૂ થાય છે અને 1 થી n સુધી ક્રમ પર પસાર થવાની પ્રક્રિયાને ઉત્તેજીત કરે છે. આઉટપુટ ક્રમમાં તેમનું સ્થાન ન મળતા તત્વો માટે પુશ અને પ Popપ operationsપરેશન્સનો ટ્ર trackક રાખવા માટે અમે વેરીએબલ હોવી જોઈએ. તેથી, એલ્ગોરિધમનો સારાંશ આપવા માટે, અમે દરેક તત્વને દબાણ કરીએ છીએ પરંતુ ખાલી તત્વોને પ popપ કરીએ છીએ જેની અમને જરૂર નથી.

સ્ટેક ઓપરેશંસ લીટકોડ સોલ્યુશન સાથે એરે બિલ્ડ માટેનો કોડ

સી ++ કોડ

#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 સુધીના દરેક તત્વોને વટાવીએ છીએ. આમ સમય જટિલતા રેખીય છે.

અવકાશ જટિલતા

ઓ (એન), કારણ કે આઉટપુટ સંગ્રહવા માટે આપણને મધ્યવર્તી વેક્ટર / એરેનો ઉપયોગ કરવાની જરૂર છે.