अमेज़ॅन साक्षात्कार प्रश्न: एक ओओ पार्किंग स्थल डिजाइन करें

Question

एक ओओ पार्किंग स्थल डिजाइन करें। इसमें कौन से वर्ग और कार्य होंगे। यह कहना चाहिए, पूर्ण, खाली और वैलेट पार्किंग के लिए जगह ढूंढने में भी सक्षम होना चाहिए। बहुत सारे पार्किंग में 3 अलग-अलग प्रकार हैं: नियमित, विकलांग और कॉम्पैक्ट।

धन्यवाद!

Answer 1

यहाँ एक जल्दी शुरू मोड़ ...

ParkingLot एक वर्ग है गियर पाने के लिए है।

पार्किंगस्पेस एक कक्षा है।

पार्किंगस्पेस में प्रवेश है।

प्रवेश में स्थान या अधिक विशेष रूप से प्रवेश से दूरी है।

पार्किंग लॉटसाइन एक कक्षा है।

पार्किंग लॉट में एक पार्किंग लॉटसाइन है।

पार्किंग लॉट में पार्किंगस्पेस की एक सीमित संख्या है।

विकलांगता पार्किंग स्पेस पार्किंगस्पेस का एक उप-वर्ग है।

नियमित स्पार्किंग स्पेस पार्किंगस्पेस का एक उप-वर्ग है।

कॉम्पैक्टपार्किंग स्पेस पार्किंगस्पेस का एक उप-वर्ग है।

पार्किंग लॉट पार्किंगस्पेस की सरणी रखता है, और इसके प्रवेश से दूरी के क्रम में खाली पार्किंग स्पेस की एक अलग सरणी रखता है।

ParkingLotSign "पूर्ण", या "खाली", या प्रदर्शित करने के लिए कहा जा सकता है .Full(), .Empty() या .normal() कॉल

पार्कर है द्वारा "खाली/सामान्य/आंशिक रूप से कब्जा कर लिया" एक कक्षा।

पार्कर पार्क()।

पार्कर अनपर्क()।

वैलेट पार्कर का एक उप-वर्ग है जो पार्किंगLot.FindVacantSpaceNearestEntrance() को कॉल कर सकता है, जो पार्किंगस्पेस देता है।

पार्कर में पार्किंगस्पेस है।

पार्कर पार्किंग स्पेस को कॉल कर सकते हैं। टेक() और पार्किंग स्पेस। वैकेट()।

पार्कर प्रवेश प्रवेश करता है। प्रवेश() और प्रवेश। निष्पादन() और पार्किंग स्पेस पार्किंग स्थल को सूचित या खाली होने पर सूचित करता है ताकि पार्किंग लॉट यह निर्धारित कर सके कि यह पूर्ण है या नहीं। यदि यह नया पूर्ण या नया खाली है या नया पूर्ण या खाली नहीं है, तो उसे पार्किंगLotSign.Full() या ParkingLotSign.Empty() या ParkingLotSign.Normal() को बदलना चाहिए।

विकलांगता पार्कर और कॉम्पैक्टपाकर पार्कर और रेगुलरपार्कर के उप-वर्ग में पार्कर के उप-वर्ग का उप-वर्ग हो सकता है। (वास्तव में अधिक हो सकता है, वास्तव में।)

इस समाधान में, यह संभव है कि पार्कर का नाम कार बनना चाहिए।

Answer 2

ऑब्जेक्ट ओरिएंटेड पार्किंग स्थल में, कर्मचारियों के लिए कोई आवश्यकता नहीं होगी क्योंकि कारें "पार्क कैसे जानती हैं"।

बहुत से उपयोग करने योग्य कार ढूंढना मुश्किल होगा; सबसे आम मॉडल में या तो उनके सभी चलती हिस्सों को सार्वजनिक सदस्य चर के रूप में उजागर किया जाएगा, या वे बिना खिड़कियों या दरवाजे वाले "पूरी तरह से encapsulated" कारें होंगी।

हमारे OO पार्किंग आकार और कारों के आकार हमारे बहुत पर

लाइसेंस टैग (रिक्त स्थान और कारों के बीच एक "impediance बेमेल ') से मेल नहीं खाएगी में पार्किंग स्थान प्रत्येक के बीच एक बिंदु होगा पत्र और अंक। विकलांग पार्किंग केवल "_" से शुरू होने वाले लाइसेंस के लिए उपलब्ध होगी, और "m_" से शुरू होने वाले लाइसेंसों को तब्दील कर दिया जाएगा।

Answer 3

आपको एक पार्किंग स्थल की आवश्यकता होगी, जिसमें एक प्रकार "अंतरिक्ष" के बहु-आयामी सरणी (कन्स्ट्रक्टर में निर्दिष्ट) हो। पार्किंग स्थल यह ट्रैक रख सकता है कि रिक्त स्थानों को भरने और रिक्त स्थान पर कॉल के माध्यम से कितनी रिक्त स्थान ली जाती हैं। स्पेस एक समेकित प्रकार रख सकता है जो बताता है कि यह किस प्रकार की जगह है। अंतरिक्ष में एक विधि भी है()। वैलेट पार्किंग के लिए, बस खुलने वाली पहली जगह ढूंढें और कार को वहां रखें। अंतरिक्ष में रखने के लिए आपको एक कार ऑब्जेक्ट की भी आवश्यकता होगी, जो यह रखता है कि यह एक विकलांग, कॉम्पैक्ट या नियमित वाहन है या नहीं।

class ParkingLot 
{ 
    Space[][] spaces; 

    ParkingLot(wide, long); // constructor 

    FindOpenSpace(TypeOfCar); // find first open space where type matches 
} 

enum TypeOfSpace = {compact, handicapped, regular }; 
enum TypeOfCar = {compact, handicapped, regular }; 

class Space 
{ 
    TypeOfSpace type; 
    bool empty; 
    // gets and sets here 
    // make sure car type 
} 

class car 
{ 
    TypeOfCar type; 
} 
 

Answer 4

मॉडल अलगाव में मौजूद नहीं हैं। एक कार पार्क में प्रवेश करने वाली कारों के सिमुलेशन के लिए आप जो संरचनाएं परिभाषित करेंगे, एक एम्बेडेड सिस्टम जो आपको एक खाली स्थान पर मार्गदर्शन करता है, एक कार पार्किंग बिलिंग सिस्टम या कार पार्क में सामान्य गेट्स/टिकट मशीनों के लिए सामान्य है।

Answer 5

public class ParkingLot 
{ 
    Vector<ParkingSpace> vacantParkingSpaces = null; 
    Vector<ParkingSpace> fullParkingSpaces = null; 

    int parkingSpaceCount = 0; 

    boolean isFull; 
    boolean isEmpty; 

    ParkingSpace findNearestVacant(ParkingType type) 
    { 
     Iterator<ParkingSpace> itr = vacantParkingSpaces.iterator(); 

     while(itr.hasNext()) 
     { 
      ParkingSpace parkingSpace = itr.next(); 

      if(parkingSpace.parkingType == type) 
      { 
       return parkingSpace; 
      } 
     } 
     return null; 
    } 

    void parkVehicle(ParkingType type, Vehicle vehicle) 
    { 
     if(!isFull()) 
     { 
      ParkingSpace parkingSpace = findNearestVacant(type); 

      if(parkingSpace != null) 
      { 
       parkingSpace.vehicle = vehicle; 
       parkingSpace.isVacant = false; 

       vacantParkingSpaces.remove(parkingSpace); 
       fullParkingSpaces.add(parkingSpace); 

       if(fullParkingSpaces.size() == parkingSpaceCount) 
        isFull = true; 

       isEmpty = false; 
      } 
     } 
    } 

    void releaseVehicle(Vehicle vehicle) 
    { 
     if(!isEmpty()) 
     { 
      Iterator<ParkingSpace> itr = fullParkingSpaces.iterator(); 

      while(itr.hasNext()) 
      { 
       ParkingSpace parkingSpace = itr.next(); 

       if(parkingSpace.vehicle.equals(vehicle)) 
       { 
        fullParkingSpaces.remove(parkingSpace); 
        vacantParkingSpaces.add(parkingSpace); 

        parkingSpace.isVacant = true; 
        parkingSpace.vehicle = null; 

        if(vacantParkingSpaces.size() == parkingSpaceCount) 
         isEmpty = true; 

        isFull = false; 
       } 
      } 
     } 
    } 

    boolean isFull() 
    { 
     return isFull; 
    } 

    boolean isEmpty() 
    { 
     return isEmpty; 
    } 
} 

public class ParkingSpace 
{ 
    boolean isVacant; 
    Vehicle vehicle; 
    ParkingType parkingType; 
    int distance; 
} 

public class Vehicle 
{ 
    int num; 
} 

public enum ParkingType 
{ 
    REGULAR, 
    HANDICAPPED, 
    COMPACT, 
    MAX_PARKING_TYPE, 
}