ਡਿਜ਼ਾਇਨ ਪਾਰਕਿੰਗ ਸਿਸਟਮ ਲੀਟਕੋਡ ਹੱਲ


ਮੁਸ਼ਕਲ ਪੱਧਰ ਸੌਖੀ
ਅਕਸਰ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ ਐਮਾਜ਼ਾਨ
ਡਿਜ਼ਾਈਨ

ਸਮੱਸਿਆ ਦਾ ਬਿਆਨ

ਇਸ ਸਮੱਸਿਆ ਵਿੱਚ, ਸਾਨੂੰ ਇੱਕ ਪਾਰਕਿੰਗ ਸਥਾਨ ਤਿਆਰ ਕਰਨਾ ਪਏਗਾ. ਸਾਡੇ ਕੋਲ ਪਾਰਕਿੰਗ ਦੀਆਂ ਤਿੰਨ ਕਿਸਮਾਂ ਹਨ (ਵੱਡੇ, ਦਰਮਿਆਨੇ ਅਤੇ ਛੋਟੇ). ਪਾਰਕਿੰਗ ਦੀਆਂ ਇਨ੍ਹਾਂ ਸਾਰੀਆਂ ਥਾਵਾਂ ਦੇ ਸ਼ੁਰੂ ਵਿਚ ਕੁਝ ਖਾਲੀ ਨੰਬਰ ਹਨ.
ਜਿਵੇਂ ਵੱਡੀ ਜਗ੍ਹਾ ਵਿਚ ਅਸੀਂ ਬਹੁਤੀਆਂ ਕਾਰਾਂ 'ਤੇ ਰੱਖ ਸਕਦੇ ਹਾਂ. ਛੋਟੀ ਕਿਸਮਾਂ ਦੀ ਜਗ੍ਹਾ ਵਿੱਚ, ਅਸੀਂ ਬਹੁਤੀਆਂ ਕਾਰਾਂ ਤੇ ਅਤੇ ਮੱਧਮ ਕਿਸਮ ਦੀ ਜਗ੍ਹਾ ਵਿੱਚ, ਐਮ ਕਾਰਾਂ ਰੱਖ ਸਕਦੇ ਹਾਂ.

ਸਾਨੂੰ ਦਿੱਤੀ ਗਈ ਕਲਾਸ ਦੇ ਨਿਰਮਾਤਾ ਵਿਚ ਮੁੱਲ, ਬੀ ਅਤੇ ਐੱਮ (ਸਾਰੇ ਤਿੰਨ ਖਾਲੀ ਥਾਂਵਾਂ ਦੀ ਅਧਿਕਤਮ ਸੀਮਾ) ਦਿੱਤੇ ਗਏ ਹਨ. ਹੁਣ, ਸਾਨੂੰ ਇਨ੍ਹਾਂ ਥਾਵਾਂ 'ਤੇ ਕੁਝ ਕਾਰਾਂ ਰੱਖਣੀਆਂ ਹਨ. ਕਾਰਾਂ ਵੀ ਤਿੰਨ ਕਿਸਮਾਂ ਦੀਆਂ ਵੱਡੀਆਂ ਛੋਟੀਆਂ ਅਤੇ ਮੱਧਮ ਹੁੰਦੀਆਂ ਹਨ. ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਸਿਰਫ ਉਹਨਾਂ ਦੇ ਆਪਣੇ ਪਾਰਕਿੰਗ ਸਥਾਨ ਵਿੱਚ ਰੱਖਿਆ ਜਾ ਸਕਦਾ ਹੈ. ਜਿਵੇਂ ਕਿ ਛੋਟੀ ਕਾਰ ਸਿਰਫ ਛੋਟੇ ਪਾਰਕਿੰਗ ਵਿੱਚ ਰੱਖੀ ਜਾ ਸਕਦੀ ਹੈ.

ਸਾਨੂੰ ਇਹ ਪਤਾ ਲਗਾਉਣਾ ਹੋਵੇਗਾ ਕਿ ਅਸੀਂ ਇਹ ਕਾਰਾਂ ਰੱਖ ਸਕਦੇ ਹਾਂ ਜਾਂ ਨਹੀਂ. ਇਸ ਉਦੇਸ਼ ਲਈ ਸਾਨੂੰ ਇੱਕ ਕਾਰਜ ਐਡਕਾਰ (ਇੰਟ ਟਾਈਪ) ਬਣਾਉਣਾ ਹੈ ਜੋ ਸਹੀ ਵਾਪਿਸ ਆਵੇਗਾ ਜੇ ਇਸ ਕਿਸਮ ਦੀ ਕਾਰ ਰੱਖੀ ਜਾ ਸਕਦੀ ਹੈ ਜਾਂ ਨਹੀਂ ਤਾਂ ਇਹ ਗਲਤ ਵਾਪਸ ਆਵੇਗੀ.

ਡਿਜ਼ਾਇਨ ਪਾਰਕਿੰਗ ਸਿਸਟਮ ਲੀਟਕੋਡ ਹੱਲ

ਉਦਾਹਰਨ

["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); // ਗਲਤ ਵਾਪਿਸ ਆਓ ਕਿਉਂਕਿ ਵੱਡੀ ਕਾਰ ਲਈ ਕੋਈ ਸਲਾਟ ਉਪਲਬਧ ਨਹੀਂ ਹੈ. ਇਹ ਪਹਿਲਾਂ ਹੀ ਕਬਜ਼ਾ ਹੈ.

ਪਹੁੰਚ

ਸਾਨੂੰ ਇੱਥੇ ਦੋ ਕੰਮ ਕਰਨੇ ਪੈਣਗੇ. ਇੱਕ ਨੂੰ ਦਿੱਤੇ ਮੁੱਲ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਹੈ ਕੰਸਟ੍ਰੈਕਟਰ. ਇਕ ਹੋਰ ਹੈ ਫੰਕਸ਼ਨ ਐਡਕਾਰ () ਨੂੰ ਬਣਾਉਣਾ.
ਹੁਣ, ਸੋਚੋ ਜੇ ਸਾਡੇ ਕੋਲ ਵੱਡੀ ਪਾਰਕਿੰਗ ਵਾਲੀ ਥਾਂ ਖਾਲੀ ਹੈ ਅਤੇ ਸਾਨੂੰ ਇਸ ਵਿਚ ਇਕ ਵੱਡੀ ਕਾਰ ਰੱਖਣੀ ਹੈ. ਬਸ, ਅਸੀਂ ਇਸ ਕਾਰ ਨੂੰ ਰੱਖਾਂਗੇ ਅਤੇ ਸਾਡੀ ਖਾਲੀ ਜਗ੍ਹਾ ਬੀ -1 ਤੇ ਆ ਜਾਵੇਗੀ.
ਉਦੋਂ ਕੀ ਜੇ ਸਾਡੇ ਕੋਲ ਵੱਡੀਆਂ ਕਾਰਾਂ ਲਈ ਖਾਲੀ ਥਾਂ ਨਹੀਂ ਹੈ? ਭਾਵ ਜਦੋਂ ਬੀ = 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): ਕੋਈ ਵਾਧੂ ਜਗ੍ਹਾ ਨਹੀਂ ਵਰਤੀ ਗਈ.