ડિઝાઇન પાર્કિંગ સિસ્ટમ લીટકોડ સોલ્યુશન


મુશ્કેલી સ્તર સરળ
વારંવાર પૂછવામાં આવે છે એમેઝોન
ડિઝાઇન

સમસ્યા નિવેદન

આ સમસ્યામાં, અમારે એક પાર્કિંગની ડિઝાઇન બનાવવી પડશે. અમારી પાસે 3 પ્રકારની પાર્કિંગ જગ્યાઓ (મોટી, મધ્યમ અને નાની) છે. આ તમામ પાર્કિંગની જગ્યાઓ પર શરૂઆતમાં કેટલાક નિયત સંખ્યામાં ખાલી સ્લોટ છે.
જેમ કે મોટી જગ્યામાં આપણે મોટાભાગની બી કાર મૂકી શકીએ છીએ. નાના પ્રકારની જગ્યામાં, આપણે મોટાભાગની કારો મૂકી શકીએ છીએ અને મધ્યમ પ્રકારની જગ્યામાં, અમે એમ કાર મૂકી શકીએ છીએ.

આપેલ વર્ગના કન્સ્ટ્રક્ટરમાં આપણને બી, એસ અને એમ (ત્રણેય જગ્યાઓની મહત્તમ મર્યાદા) આપવામાં આવે છે. હવે, આપણે આ જગ્યાઓ પર કેટલીક કાર મૂકવી પડશે. આ કાર પણ ત્રણ પ્રકારની મોટી અને મોટી હોય છે. અને તેઓ ફક્ત તેમના સંબંધિત પાર્કિંગમાં જ મૂકી શકાય છે. નાની કારની જેમ જ નાના પાર્કિંગમાં મૂકી શકાય છે.

આપણે આ કાર મૂકી શકીએ કે નહીં તે શોધવું પડશે. આ હેતુ માટે આપણે ફંક્શન Cડકાર (ઇન્ટ ટાઇપ) બનાવવું પડશે જે આ પ્રકારની કાર મૂકી શકાય કે નહીં તો સાચું પાછું આવશે, નહીં તો આ ખોટું પાછું ફરશે.

ડિઝાઇન પાર્કિંગ સિસ્ટમ લીટકોડ સોલ્યુશન

ઉદાહરણ

["ParkingSystem", "addCar", "addCar", "addCar", "addCar"]
[[1, 1, 0], [1], [2], [3], [1]]
[null, true, true, false, false]

સમજૂતી:

1. પાર્કિંગસિસ્ટમ .એડીડીકાર (1); // રીટર્ન સાચું કારણ કે મોટી કાર માટે 1 ઉપલબ્ધ સ્લોટ છે
2. પાર્કિંગસિસ્ટમ .એડીડીકાર (2); // રીટર્ન સાચું કારણ કે મધ્યમ કાર માટે 1 ઉપલબ્ધ સ્લોટ છે
3. પાર્કિંગસિસ્ટમ .એડીડીકાર (3); // રીટર્ન ખોટું કારણ કે નાની કાર માટે કોઈ સ્લોટ ઉપલબ્ધ નથી
4. પાર્કિંગસિસ્ટમ .એડીડીસીએઆર (1); // રીટર્ન ખોટું કારણ કે મોટી કાર માટે કોઈ સ્લોટ ઉપલબ્ધ નથી. તેનો કબજો પહેલેથી જ છે.

અભિગમ

આપણે અહીં બે કાર્ય કરવાના છે. એક આપેલ કિંમતોનો ઉપયોગ કરવો બિલ્ડર. બીજું ફંક્શન functionડકાર () ને બનાવવાનું છે.
હવે વિચારો કે જો આપણી પાસે મોટી પાર્કિંગની ખાલી જગ્યાઓ છે અને આપણે આમાં મોટી કાર મૂકવી પડશે. ખાલી, અમે આ કાર મૂકીશું અને આપણી ખાલી જગ્યા બી -1 પર આવી જશે.
જો અમારી પાસે મોટી કાર માટેની જગ્યાઓ ન હોય તો? એટલે કે જ્યારે b = 0, અમે કોઈ મોટી કાર મૂકી શકતા નથી.

અમારો અભિગમ પણ તે જ કરી રહ્યો છે. દરેક પાર્કિંગ સ્લોટ્સની ખાલી જગ્યાઓની સંખ્યા બતાવવા માટે, અમે આપેલા વર્ગમાં ત્રણ વૈશ્વિક ચલો (મોટા, નાના અને મધ્યમ દો) બનાવ્યાં છે. આપણે તેમના વેલ્યુઓને કન્સ્ટ્રક્ટરમાં આપેલા વેલ્યુથી પ્રારંભ કરી રહ્યા છીએ.
હવે, અમે એડકાર () વિનંતી પર પ્રક્રિયા કરી શકીએ છીએ.

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

અમલીકરણ

ડિઝાઇન પાર્કિગ સિસ્ટમ, લેટકોડ સોલ્યુશન માટે સી ++ પ્રોગ્રામ

#include<iostream>
using namespace std;

class ParkingSystem {
public:
    
    int big,medium,small;
    ParkingSystem(int big1, int medium1, int small1)
    {
        big=big1;
        medium=medium1;
        small=small1;
    }
    
    bool addCar(int carType)
    {
        if(carType==1){
            if(big==0)return false;
            big--;
        }else if(carType==2){
            if(medium==0)return false;
            medium--;
            
        }else{
            if(small==0)return false;
            small--;
            
        }
        return true;
    }
};


int main()
{
        ParkingSystem obj = ParkingSystem(1,1,0);
        obj.addCar(1)?cout<<"true ":cout<<"false ";
        obj.addCar(2)?cout<<"true ":cout<<"false ";
        obj.addCar(3)?cout<<"true ":cout<<"false ";
        obj.addCar(1)?cout<<"true ":cout<<"false ";
        
        return 0;
}
true true false false

ડિઝાઇન પાર્કિંગ પાર્કિંગ લીટકોડ સોલ્યુશન માટે જાવા પ્રોગ્રામ

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

class ParkingSystem {
    int big,medium,small;
    public ParkingSystem(int big, int medium, int small) 
    {
        this.big=big;
        this.medium=medium;
        this.small=small;
    }
    
    public boolean addCar(int carType) 
    {
        if(carType==1){
            if(big==0)return false;
            big--;
        }else if(carType==2){
            if(medium==0)return false;
            medium--;
            
        }else{
            if(small==0)return false;
            small--;
            
        }
        return true;
    }
}


class Solution
{  
    public static void main(String args[])
    {
        ParkingSystem obj=new ParkingSystem(1,1,0);
        System.out.print(obj.addCar(1)+" ");
        System.out.print(obj.addCar(2)+" ");
        System.out.print(obj.addCar(3)+" ");
        System.out.print(obj.addCar(1)+" ");
    }
}
true true false false

ડિઝાઇન પાર્કિંગ સિસ્ટમ લેટકોડ સોલ્યુશન માટે જટિલતા વિશ્લેષણ

સમય જટિલતા

ઓ (1): અલ્ગોરિધમનો સરળ છે જો અન્ય કાર્યો. આમ સમય જટિલતા ઓ (1) છે.

અવકાશ જટિલતા 

ઓ (1): કોઈ વધારાની જગ્યા વપરાયેલ નથી.