ವಿನ್ಯಾಸ ಪಾರ್ಕಿಂಗ್ ವ್ಯವಸ್ಥೆ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರ


ತೊಂದರೆ ಮಟ್ಟ ಸುಲಭ
ಆಗಾಗ್ಗೆ ಕೇಳಲಾಗುತ್ತದೆ ಅಮೆಜಾನ್
ಡಿಸೈನ್

ಸಮಸ್ಯೆ ಹೇಳಿಕೆ

ಈ ಸಮಸ್ಯೆಯಲ್ಲಿ, ನಾವು ಪಾರ್ಕಿಂಗ್ ಸ್ಥಳವನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸಬೇಕು. ನಮ್ಮಲ್ಲಿ 3 ರೀತಿಯ ಪಾರ್ಕಿಂಗ್ ಸ್ಥಳಗಳಿವೆ (ದೊಡ್ಡ, ಮಧ್ಯಮ ಮತ್ತು ಸಣ್ಣ). ಈ ಎಲ್ಲಾ ಪಾರ್ಕಿಂಗ್ ಸ್ಥಳಗಳು ಆರಂಭದಲ್ಲಿ ಕೆಲವು ಸ್ಥಿರ ಸಂಖ್ಯೆಯ ಖಾಲಿ ಸ್ಲಾಟ್‌ಗಳನ್ನು ಹೊಂದಿವೆ.
ದೊಡ್ಡ ರೀತಿಯ ಜಾಗದಲ್ಲಿ, ನಾವು ಹೆಚ್ಚಿನ ಬಿ ಕಾರುಗಳಲ್ಲಿ ಇರಿಸಬಹುದು. ಸಣ್ಣ ರೀತಿಯ ಜಾಗದಲ್ಲಿ, ನಾವು ಹೆಚ್ಚಿನ ಕಾರುಗಳಲ್ಲಿ ಇರಿಸಬಹುದು ಮತ್ತು ಮಧ್ಯಮ ರೀತಿಯ ಜಾಗದಲ್ಲಿ, ನಾವು m ಕಾರುಗಳನ್ನು ಇರಿಸಬಹುದು.

ನಿರ್ದಿಷ್ಟ ವರ್ಗದ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ನಲ್ಲಿ ನಮಗೆ b, s ಮತ್ತು m (ಎಲ್ಲಾ ಮೂರು ಸ್ಥಳಗಳ ಗರಿಷ್ಠ ಮಿತಿ) ಮೌಲ್ಯಗಳನ್ನು ನೀಡಲಾಗುತ್ತದೆ. ಈಗ, ನಾವು ಈ ಸ್ಥಳಗಳಲ್ಲಿ ಕೆಲವು ಕಾರುಗಳನ್ನು ಇಡಬೇಕಾಗಿದೆ. ಕಾರುಗಳು ದೊಡ್ಡ ಮತ್ತು ಸಣ್ಣ ಮೂರು ವಿಧಗಳಾಗಿವೆ. ಮತ್ತು ಅವುಗಳನ್ನು ಆಯಾ ವಾಹನ ನಿಲುಗಡೆಗೆ ಮಾತ್ರ ಇರಿಸಬಹುದು. ಸಣ್ಣ ಕಾರಿನಂತೆ ಸಣ್ಣ ಪಾರ್ಕಿಂಗ್ ಸ್ಥಳದಲ್ಲಿ ಮಾತ್ರ ಇರಿಸಬಹುದು.

ನಾವು ಈ ಕಾರುಗಳನ್ನು ಇಡಬಹುದೇ ಅಥವಾ ಇಲ್ಲವೇ ಎಂಬುದನ್ನು ಕಂಡುಹಿಡಿಯಬೇಕು. ಈ ಉದ್ದೇಶಕ್ಕಾಗಿ ನಾವು ಆಡ್ಕಾರ್ (ಇಂಟ್ ಪ್ರಕಾರ) ಎಂಬ ಕಾರ್ಯವನ್ನು ರಚಿಸಬೇಕಾಗಿದೆ, ಅದು ಈ ಪ್ರಕಾರದ ಕಾರನ್ನು ಇಡಲು ಸಾಧ್ಯವಾದರೆ ಅದು ನಿಜವಾಗುತ್ತದೆ ಅಥವಾ ಇಲ್ಲದಿದ್ದರೆ ಇದು ಸುಳ್ಳನ್ನು ನೀಡುತ್ತದೆ.

ವಿನ್ಯಾಸ ಪಾರ್ಕಿಂಗ್ ವ್ಯವಸ್ಥೆ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರ

ಉದಾಹರಣೆ

["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 ಕ್ಕೆ ಇಳಿಯುತ್ತದೆ.
ದೊಡ್ಡ ಕಾರುಗಳಿಗೆ ನಮ್ಮಲ್ಲಿ ಖಾಲಿ ಸ್ಥಳಗಳಿಲ್ಲದಿದ್ದರೆ ಏನು? ಅಂದರೆ 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): ಯಾವುದೇ ಹೆಚ್ಚುವರಿ ಸ್ಥಳವನ್ನು ಬಳಸಲಾಗಿಲ್ಲ.