Rotate String

N-Queens

Check whether one string can be rotated to become another.

Given two strings `s` and `goal`, return `true` if and only if `s` can become `goal` after some number of rotations.

A rotation moves the leftmost character of the string to the rightmost end. For example, rotating `"abcde"` once produces `"bcdea"`.

An equivalent way to think about the problem is: `goal` is a rotation of `s` if the two strings have the same length and `goal` appears inside `s + s`.

**Input / output**
- Input: `s: string`, `goal: string`
- Output: `boolean`

## Examples
```
Input: {"s":"abcde","goal":"cdeab"}
Output: true
```

```
Input: {"s":"abcde","goal":"abced"}
Output: false
```

```
Input: {"s":"aaaa","goal":"aaaa"}
Output: true
```

## Constraints
- `1 <= s.length, goal.length <= 100`
- `s` and `goal` consist of lowercase English letters.

## Follow-up
How would you check whether `goal` is a rotation of `s` without explicitly building the doubled string `s + s`?

- Rotating a string does not change its length or multiset of characters.
- More specifically, every rotation of `s` appears as a contiguous slice inside `s + s`.
- So the problem reduces to checking equal lengths first, then substring containment.

Recognize the Pattern

- If `s` and `goal` have different lengths, return `False` immediately.
- Otherwise form the doubled string `s + s`.
- Return whether `goal` appears inside that doubled string.

Build the Algorithm

- Identical strings should return `True` because zero rotations are allowed.
- Single-character strings work naturally with the same check.
- Repeated characters are safe because substring containment on `s + s` still distinguishes real rotations from lookalikes.

Check Edge Cases

- The doubled-string trick captures every possible rotation exactly where it starts in `s + s`.
- The algorithm runs in `O(n)` time for strings of length `n` and uses `O(n)` extra space for the doubled string.