# Categorize Box According to Criteria
**Difficulty:** EASY
[External](https://leetcode.com/problems/categorize-box-according-to-criteria)
Canonical: https://scaleengineer.com/dsa/problems/categorize-box-according-to-criteria
**Patterns:** [Math](https://scaleengineer.com/dsa/patterns/math)
**Companies:** [Zendesk](https://scaleengineer.com/companies/zendesk)
---
## Problem
Given four integers `length`, `width`, `height`, and `mass`, representing the dimensions and mass of a box, respectively, return _a string representing the **category** of the box_.

* The box is `"Bulky"` if:  
  * **Any** of the dimensions of the box is greater or equal to `104`.
  * Or, the **volume** of the box is greater or equal to `109`.
* If the mass of the box is greater or equal to `100`, it is `"Heavy".`
* If the box is both `"Bulky"` and `"Heavy"`, then its category is `"Both"`.
* If the box is neither `"Bulky"` nor `"Heavy"`, then its category is `"Neither"`.
* If the box is `"Bulky"` but not `"Heavy"`, then its category is `"Bulky"`.
* If the box is `"Heavy"` but not `"Bulky"`, then its category is `"Heavy"`.

**Note** that the volume of the box is the product of its length, width and height.

**Example 1:**

**Input:** length = 1000, width = 35, height = 700, mass = 300
**Output:** "Heavy"
**Explanation:** 
None of the dimensions of the box is greater or equal to 104. 
Its volume = 24500000 <= 109. So it cannot be categorized as "Bulky".
However mass >= 100, so the box is "Heavy".
Since the box is not "Bulky" but "Heavy", we return "Heavy".

**Example 2:**

**Input:** length = 200, width = 50, height = 800, mass = 50
**Output:** "Neither"
**Explanation:** 
None of the dimensions of the box is greater or equal to 104.
Its volume = 8 * 106 <= 109. So it cannot be categorized as "Bulky".
Its mass is also less than 100, so it cannot be categorized as "Heavy" either. 
Since its neither of the two above categories, we return "Neither".

**Constraints:**

* `1 <= length, width, height <= 105`
* `1 <= mass <= 103`

# Approaches
## Direct Conditional Logic
The problem asks us to categorize a box based on a set of rules related to its dimensions and mass. This can be solved by directly implementing the given logic. We first determine if the box qualifies as "Bulky" and if it qualifies as "Heavy" by checking their respective conditions. These two properties can be stored in boolean flags. Then, based on the combination of these two flags, we can use a simple conditional structure (`if-else if-else`) to return the correct category string.
**Time:** O(1) - The solution consists of a fixed number of arithmetic operations and comparisons. The runtime does not depend on the magnitude of the input values, making it constant time. · **Space:** O(1) - The algorithm uses a constant amount of extra space for a few variables (two booleans and one long for volume), regardless of the input values.
**Pros:** Optimal performance with constant time and space complexity.; The code is simple, readable, and a direct translation of the problem statement.; Easy to implement and debug.
**Cons:** A potential pitfall is integer overflow when calculating the volume. This must be handled by using a 64-bit integer type (`long` in Java).
### Explanation
This approach is a direct simulation of the problem's requirements. It's the most straightforward and efficient way to solve the problem.

First, we need to determine the two primary properties of the box: whether it's "Bulky" and whether it's "Heavy".

1.  **Bulky Check**: A box is bulky if any of its dimensions (`length`, `width`, `height`) is at least 10,000, OR its volume is at least 10<sup>9</sup>. A critical detail here is that the dimensions can be up to 10<sup>5</sup>, so their product can be up to (10<sup>5</sup>)<sup>3</sup> = 10<sup>15</sup>. This value will overflow a standard 32-bit integer. Therefore, we must use a 64-bit integer type (`long` in Java) for the volume calculation.

2.  **Heavy Check**: A box is heavy if its `mass` is at least 100. This is a simple comparison.

After determining these two boolean states, we can map the four possible outcomes to the required category strings:

-   `isBulky = true`, `isHeavy = true` -> "Both"
-   `isBulky = true`, `isHeavy = false` -> "Bulky"
-   `isBulky = false`, `isHeavy = true` -> "Heavy"
-   `isBulky = false`, `isHeavy = false` -> "Neither"

This logic is perfectly suited for an `if-else` cascade.

Here is the Java implementation:
```java
class Solution {
    public String categorizeBox(int length, int width, int height, int mass) {
        // Use long for volume to prevent integer overflow
        long volume = (long) length * width * height;

        // Determine if the box is Bulky
        boolean isBulky = (length >= 10000 || width >= 10000 || height >= 10000 || volume >= 1000000000);

        // Determine if the box is Heavy
        boolean isHeavy = (mass >= 100);

        // Categorize based on the boolean flags
        if (isBulky && isHeavy) {
            return "Both";
        } else if (isBulky) {
            return "Bulky";
        } else if (isHeavy) {
            return "Heavy";
        } else {
            return "Neither";
        }
    }
}
```
### Algorithm
- Create two boolean flags, `isBulky` and `isHeavy`, initialized to `false`.
- Evaluate the "Bulky" condition:
  - Check if `length >= 10000`, `width >= 10000`, or `height >= 10000`.
  - Calculate the volume using a `long` data type to prevent overflow: `long volume = (long)length * width * height;`.
  - Check if `volume >= 10^9`.
  - If any of the above conditions are true, set `isBulky` to `true`.
- Evaluate the "Heavy" condition:
  - Check if `mass >= 100`.
  - If true, set `isHeavy` to `true`.
- Use a series of `if-else` statements to determine the final category based on the boolean flags:
  - If `isBulky` and `isHeavy` are both true, return "Both".
  - If only `isBulky` is true, return "Bulky".
  - If only `isHeavy` is true, return "Heavy".
  - If neither is true, return "Neither".

# Solutions
### Java

```java
class Solution {
public
  String categorizeBox(int length, int width, int height, int mass) {
    long v = (long)length * width * height;
    int bulky =
        length >= 10000 || width >= 10000 || height >= 10000 || v >= 1000000000
            ? 1
            : 0;
    int heavy = mass >= 100 ? 1 : 0;
    String[] d = {"Neither", "Bulky", "Heavy", "Both"};
    int i = heavy << 1 | bulky;
    return d[i];
  }
}

```

### CPP

```cpp
class Solution {
public:
  string categorizeBox(int length, int width, int height, int mass) {
    long v = (long)length * width * height;
    int bulky =
        length >= 10000 || width >= 10000 || height >= 10000 || v >= 1000000000
            ? 1
            : 0;
    int heavy = mass >= 100 ? 1 : 0;
    string d[4] = {"Neither", "Bulky", "Heavy", "Both"};
    int i = heavy << 1 | bulky;
    return d[i];
  }
};

```

### Python

```python
class Solution:
    def categorizeBox(self, length: int, width: int, height: int, mass: int) -> str: v = length * width * height bulky = int(any(x >= 10000 for x in (length, width, height)) or v >= 10 ** 9) heavy = int(mass >= 100) i = heavy << 1 | bulky d = ['Neither', 'Bulky', 'Heavy', 'Both'] return d[i]

```