Domanda dell'intervista Amazon: progettare un parcheggio OO [chiuso]

Progetta un parcheggio OO. Quali classi e funzioni avrà. Dovrebbe dire, pieno, vuoto e anche essere in grado di trovare posto per il parcheggio custodito. Il lotto dispone di 3 diverse tipologie di parcheggio: regolare, portatori di handicap e compatto.

Grazie!

Ecco un rapido inizio per far girare le marce ...

ParkingLot è una classe.

ParkingSpace è una classe.

ParkingSpace ha un ingresso.

L'ingresso ha una posizione o, più specificamente, una distanza dall'ingresso.

ParkingLotSign è una classe.

ParkingLot ha un ParkingLotSign.

ParkingLot ha un numero finito di ParkingSpaces.

HandicappedParkingSpace è una sottoclasse di ParkingSpace.

RegularParkingSpace è una sottoclasse di ParkingSpace.

CompactParkingSpace è una sottoclasse di ParkingSpace.

ParkingLot mantiene un array di ParkingSpaces e un array separato di ParkingSpaces liberi in ordine di distanza dal suo ingresso.

ParkingLotSign può essere detto di visualizzare "pieno", o "vuoto", o "vuoto / normale / parzialmente occupato" chiamando .Full (), .Empty () o .Normal ()

Parker è una classe.

Parker può parcheggiare ().

Parker può annullare il parcheggio ().

Valet è una sottoclasse di Parker che può chiamare ParkingLot.FindVacantSpaceNearestEntrance (), che restituisce ParkingSpace.

Parker dispone di ParkingSpace.

Parker può chiamare ParkingSpace.Take () e ParkingSpace.Vacate ().

Parker chiama Entrance.Entering () e Entrance.Exiting () e ParkingSpace notifica ParkingLot quando viene preso o lasciato libero in modo che ParkingLot possa determinare se è pieno o meno. Se è nuovo pieno o appena vuoto o non è pieno o vuoto, dovrebbe cambiare ParkingLotSign.Full () o ParkingLotSign.Empty () o ParkingLotSign.Normal ().

HandicappedParker potrebbe essere una sottoclasse di Parker e CompactParker una sottoclasse di Parker e RegularParker una sottoclasse di Parker. (potrebbe essere eccessivo, in realtà.)

In questa soluzione, è possibile che Parker debba essere rinominato Auto.

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,
}

I modelli non esistono isolati. Le strutture che definiresti per una simulazione di auto che entrano in un parcheggio, un sistema embedded che ti guida verso uno spazio libero, un sistema di fatturazione dei parcheggi o per i varchi / distributori automatici di biglietti usuali nei parcheggi sono tutte diverse.

In un parcheggio Object Oriented, non ci sarà bisogno di guardiani perché le auto "sapranno parcheggiare".

Trovare un'auto utilizzabile sul lotto sarà difficile; i modelli più comuni o avranno tutte le loro parti mobili esposte come variabili membro pubblico, oppure saranno auto "completamente incapsulate" senza finestre o porte.

Gli spazi di parcheggio nel nostro parcheggio OO non corrisponderanno alle dimensioni e alla forma delle auto (un "disadattamento di impedenza" tra gli spazi e le auto)

Le etichette di licenza sul nostro lotto avranno un punto tra ogni lettera e cifra. Il parcheggio per disabili sarà disponibile solo per le licenze che iniziano con "_" e le licenze che iniziano con "m_" verranno rimorchiate.

avresti bisogno di un parcheggio, che contenga un array multidimensionale (specificato nel costruttore) di tipo "spazio". Il parcheggio può tenere traccia di quanti spazi vengono occupati tramite chiamate a funzioni che riempiono e svuotano spazi. Lo spazio può contenere un tipo enumerato che indica che tipo di spazio è. Lo spazio ha anche un metodo take (). per il parcheggio custodito, basta trovare il primo spazio aperto e mettere l'auto lì. Avrai anche bisogno di un oggetto Auto da mettere nello spazio, che possa contenere sia che si tratti di un veicolo per disabili, compatto o normale.

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;
}