> For the complete documentation index, see [llms.txt](https://jaywin.gitbook.io/leetcode/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://jaywin.gitbook.io/leetcode/solutions/0379-design-phone-directory.md).

# 0379. Design Phone Directory

<https://leetcode.com/problems/design-phone-directory>

## Description

Design a phone directory that initially has `maxNumbers` empty slots that can store numbers. The directory should store numbers, check if a certain slot is empty or not, and empty a given slot.

Implement the `PhoneDirectory` class:

* `PhoneDirectory(int maxNumbers)` Initializes the phone directory with the number of available slots `maxNumbers`.
* `int get()` Provides a number that is not assigned to anyone. Returns `-1` if no number is available.
* `bool check(int number)` Returns `true` if the slot `number` is available and `false` otherwise.
* `void release(int number)` Recycles or releases the slot `number`.

**Example 1:**

```
**Input**
["PhoneDirectory", "get", "get", "check", "get", "check", "release", "check"]
[[3], [], [], [2], [], [2], [2], [2]]
**Output**
[null, 0, 1, true, 2, false, null, true]
**Explanation**
PhoneDirectory phoneDirectory = new PhoneDirectory(3);
phoneDirectory.get();      // It can return any available phone number. Here we assume it returns 0.
phoneDirectory.get();      // Assume it returns 1.
phoneDirectory.check(2);   // The number 2 is available, so return true.
phoneDirectory.get();      // It returns 2, the only number that is left.
phoneDirectory.check(2);   // The number 2 is no longer available, so return false.
phoneDirectory.release(2); // Release number 2 back to the pool.
phoneDirectory.check(2);   // Number 2 is available again, return true.
```

**Constraints:**

* `1 <= maxNumbers <= 104`
* `0 <= number < maxNumbers`
* At most `2 * 104` calls will be made to `get`, `check`, and `release`.

## ac

```java
class PhoneDirectory {
    LinkedHashSet<Integer> valid;
    Set<Integer> used;
    /** Initialize your data structure here
        @param maxNumbers - The maximum numbers that can be stored in the phone directory. */
    public PhoneDirectory(int maxNumbers) {
        valid = new LinkedHashSet<>();
        used = new HashSet<>();
        for (int i = 0; i < maxNumbers; i++) valid.add(i);
    }

    /** Provide a number which is not assigned to anyone.
        @return - Return an available number. Return -1 if none is available. */
    public int get() {
        if (valid.size() == 0) return -1;
        int res = valid.iterator().next();
        valid.remove(res);
        used.add(res);
        return res;
    }

    /** Check if a number is available or not. */
    public boolean check(int number) {
        if (!valid.contains(number)) return false;
        else return true;
    }

    /** Recycle or release a number. */
    public void release(int number) {
        if (!used.contains(number)) return;
        used.remove(number);
        valid.add(number);
    }
}

/**
 * Your PhoneDirectory object will be instantiated and called as such:
 * PhoneDirectory obj = new PhoneDirectory(maxNumbers);
 * int param_1 = obj.get();
 * boolean param_2 = obj.check(number);
 * obj.release(number);
 */

/*
LinkedHashSet<Integer> valid; Set<Integer> used;
*/
```