Implement the ParkingSystem class:

• ParkingSystem(int big, int medium, int small) Initializes object of the ParkingSystem class. The number of slots for each parking space are given as part of the constructor.
• bool addCar(int carType) Checks whether there is a parking space of carType for the car that wants to get into the parking lot. carType can be of three kinds: big, medium, or small, which are represented by 1, 2, and 3 respectively. A car can only park in a parking space of its carType. If there is no space available, return false, else park the car in that size space and return true.

Example 1:

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

Explanation ParkingSystem parkingSystem = new ParkingSystem(1, 1, 0); parkingSystem.addCar(1); // return true because there is 1 available slot for a big car parkingSystem.addCar(2); // return true because there is 1 available slot for a medium car parkingSystem.addCar(3); // return false because there is no available slot for a small car parkingSystem.addCar(1); // return false because there is no available slot for a big car. It is already occupied.

Constraints:

• 0 <= big, medium, small <= 1000
• carType is 1, 2, or 3
• At most 1000 calls will be made to addCar

Solution: Simulation

Time complexity: O(1) per addCar call
Space complexity: O(1)

// Author: Huahua
class ParkingSystem {
public:
  ParkingSystem(int big, int medium, int small): 
    slots_{{big, medium, small}} {}

  bool addCar(int carType) {
    return slots_[carType - 1]-- > 0;
  }
private:
  vector<int> slots_;
};

# Author: Huahua
class ParkingSystem:
  def __init__(self, big: int, medium: int, small: int):
    self.slots = {1: big, 2: medium, 3: small}

  def addCar(self, carType: int) -> bool:
    if self.slots[carType] == 0: return False
    self.slots[carType] -= 1
    return True

The post 花花酱 LeetCode 1603. Design Parking System appeared first on Huahua's Tech Road.

1. checkIn(int id, string stationName, int t)

• A customer with id card equal to id, gets in the station stationName at time t.
• A customer can only be checked into one place at a time.

2. checkOut(int id, string stationName, int t)

• A customer with id card equal to id, gets out from the station stationName at time t.

3. getAverageTime(string startStation, string endStation) 

• Returns the average time to travel between the startStation and the endStation.
• The average time is computed from all the previous traveling from startStation to endStation that happened directly.
• Call to getAverageTime is always valid.

You can assume all calls to checkIn and checkOut methods are consistent. That is, if a customer gets in at time t₁ at some station, then it gets out at time t₂ with t₂ > t₁. All events happen in chronological order.

Example 1:

Input
["UndergroundSystem","checkIn","checkIn","checkIn","checkOut","checkOut","checkOut","getAverageTime","getAverageTime","checkIn","getAverageTime","checkOut","getAverageTime"]
[[],[45,"Leyton",3],[32,"Paradise",8],[27,"Leyton",10],[45,"Waterloo",15],[27,"Waterloo",20],[32,"Cambridge",22],["Paradise","Cambridge"],["Leyton","Waterloo"],[10,"Leyton",24],["Leyton","Waterloo"],[10,"Waterloo",38],["Leyton","Waterloo"]]

Output
[null,null,null,null,null,null,null,14.0,11.0,null,11.0,null,12.0]

Explanation
UndergroundSystem undergroundSystem = new UndergroundSystem();
undergroundSystem.checkIn(45, "Leyton", 3);
undergroundSystem.checkIn(32, "Paradise", 8);
undergroundSystem.checkIn(27, "Leyton", 10);
undergroundSystem.checkOut(45, "Waterloo", 15);
undergroundSystem.checkOut(27, "Waterloo", 20);
undergroundSystem.checkOut(32, "Cambridge", 22);
undergroundSystem.getAverageTime("Paradise", "Cambridge");       // return 14.0. There was only one travel from "Paradise" (at time 8) to "Cambridge" (at time 22)
undergroundSystem.getAverageTime("Leyton", "Waterloo");          // return 11.0. There were two travels from "Leyton" to "Waterloo", a customer with id=45 from time=3 to time=15 and a customer with id=27 from time=10 to time=20. So the average time is ( (15-3) + (20-10) ) / 2 = 11.0
undergroundSystem.checkIn(10, "Leyton", 24);
undergroundSystem.getAverageTime("Leyton", "Waterloo");          // return 11.0
undergroundSystem.checkOut(10, "Waterloo", 38);
undergroundSystem.getAverageTime("Leyton", "Waterloo");          // return 12.0

Constraints:

• There will be at most 20000 operations.
• 1 <= id, t <= 10^6
• All strings consist of uppercase, lowercase English letters and digits.
• 1 <= stationName.length <= 10
• Answers within 10^-5 of the actual value will be accepted as correct.

Solution: Hashtable

For each user, store the checkin station and time.
For each trip (startStation + “_” + endStation), store the total time and counts.

Time complexity: O(n)
Space complexity: O(n)

// Author: Huahua
class UndergroundSystem {
public:
  UndergroundSystem() {}

  void checkIn(int id, string stationName, int t) {
    m_[id] = {stationName, t};
  }

  void checkOut(int id, string stationName, int t) {
    const auto& [s0, t0] = m_[id];
    string key = s0 + "_" + stationName;
    times_[key].first += (t - t0);
    ++times_[key].second;
  }

  double getAverageTime(string startStation, string endStation) {
    const auto& [sum, count] = times_[startStation + "_" + endStation];
    return static_cast<double>(sum) / count;
  }
private:
  unordered_map<int, pair<string, int>> m_; // id -> {station, t}
  unordered_map<string, pair<int, int>> times_; // trip -> {sum, count}
};

The post 花花酱 LeetCode 1396. Design Underground System appeared first on Huahua's Tech Road.

Input:"-1/2+1/2"
Output: "0/1"

Input:"-1/2+1/2+1/3"
Output: "1/3"

Input:"1/3-1/2"
Output: "-1/6"

Input:"5/3+1/3"
Output: "2/1"

Solution: Math

a/b+c/d = (a*d + b * c) / (b * d)

Time complexity: O(n)

Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  string fractionAddition(string expression) {
    int a = 0;
    int b = 1;    
    int c;
    int d;
    char slash;
    istringstream in(expression);
    while (in >> c >> slash >> d) {
      a = a * d + b * c;
      b *= d;
      int gcd = abs(__gcd(a, b));
      a /= gcd;
      b /= gcd;      
    }
    return to_string(a) + "/" + to_string(b);
  }
};

// Author: Huahua
// Running time: 0 ms
class Fraction {
public:
  Fraction(int a, int b): a_(a), b_(b) {}
  Fraction& operator+=(const Fraction& f) {
    a_ = a_ * f.b_ + b_ * f.a_;
    b_ = b_ * f.b_;
    int d = abs(__gcd(a_, b_));
    a_ /= d;
    b_ /= d;
    return *this;
  }
  
  string toString() {
    return to_string(a_) + "/" + to_string(b_);
  }
private:
  int a_; // hold the sign, e.g. can be +-.
  int b_; // always > 0.
};

class Solution {
public:
    string fractionAddition(string expression) {
      Fraction f(0, 1);
      int a;
      int b;
      char op;
      istringstream in(expression);
      while (in >> a >> op >> b)
        f += Fraction(a, b);  
      return f.toString();
    }
};

The post 花花酱 LeetCode 592. Fraction Addition and Subtraction appeared first on Huahua's Tech Road.