Beginner-Friendly Calculate Delayed Arrival Time Problem ⏰
IntuitionThe task is to calculate the delayed arrival time by adding the arrival time and the delayed time, ensuring that the result stays within a 24-hour cloc

# Intuition
The task is to calculate the delayed arrival time by adding the arrival time and the delayed time, ensuring that the result stays within a 24-hour clock format (i.e., it should return values between 0 and 23). The approach involves simply adding the arrival time and delayed time and adjusting the result to wrap around if the sum exceeds 24 hours.

# Approach
To solve this, we can follow these steps:
1. Add the `arrivalTime` and `delayedTime`.
2. If the result is exactly 24, return 0, as it should represent the start of the next day.
3. If the result is greater than 24, subtract 24 to get the time in the range [0, 23].
4. If the result is less than 24, just return the sum as the answer.

# Complexity
- **Time complexity**: $$O(1)$$ - The algorithm performs a constant amount of work, regardless of the input.
- **Space complexity**: $$O(1)$$ - Only a constant amount of extra space is used.

# Code
```java
class Solution {
    public int findDelayedArrivalTime(int arrivalTime, int delayedTime) {
        int ans = arrivalTime + delayedTime;
        
        if(ans == 24) {
            return 0; 
        } else if (ans > 24) {
            ans = ans - 24; 
            return ans;
        }
        
        return ans;
    }
}
```

# Explanation of Code:
- We add the `arrivalTime` and `delayedTime` to calculate the total time.
- If the sum equals exactly 24, it means the clock should reset to 0 (the start of a new day).
- If the sum is greater than 24, we subtract 24 to keep the time within the 24-hour format.
- If the sum is less than 24, we simply return the sum as the delayed arrival time.

# Example:

### Example 1:
**Input**:
- arrivalTime = 15
- delayedTime = 10

**Output**:
- The total time would be `15 + 10 = 25`. Since this is greater than 24, we subtract 24 to get `25 - 24 = 1`. Thus, the delayed arrival time is 1.

### Example 2:
**Input**:
- arrivalTime = 23
- delayedTime = 2

**Output**:
- The total time would be `23 + 2 = 25`. Again, this exceeds 24, so we subtract 24 to get `25 - 24 = 1`. The delayed arrival time is 1.

### Example 3:
**Input**:
- arrivalTime = 22
- delayedTime = 2

**Output**:
- The total time would be `22 + 2 = 24`. Since the sum is exactly 24, it wraps around to 0. Therefore, the delayed arrival time is 0.

### Example 4:
**Input**:
- arrivalTime = 13
- delayedTime = 11

**Output**:
- The total time would be `13 + 11 = 24`. Since the sum is exactly 24, it wraps around to 0. Therefore, the delayed arrival time is 0.

['Java']