| Ethan's doing his very first programming assignment: implementing a | |
| `contains()` function. This function takes two strings, **A** and **B**, and | |
| returns `true` if **A** is a substring of **B**, and `false` otherwise. | |
| Here's the algorithm that Ethan has come up with. Note that |**A**| denotes | |
| the length of **A**, and the individual characters of the strings are | |
| 1-indexed. | |
| 1. Set _i_ and _j_ to each be equal to 1. | |
| 2. If _i_ > |**A**|, return `true`. | |
| 3. If _j_ > |**B**|, return `false`. | |
| 4. If **Ai** = **Bj**, increment _i_ and _j_ by 1 each, and return to Step 2. | |
| 5. If _i_ = 1, increment _j_ by 1, and return to Step 2. | |
| 6. Set _i_ to be equal to 1, and return to Step 2. | |
| As the TA in charge of grading Ethan's assignment, this doesn't look quite | |
| right to you. To make sure Ethan doesn't get any more credit than he deserves, | |
| you'd like to find some inputs for which his algorithm returns `false` even | |
| though it should return `true`. | |
| The professor teaching this class has provided you with a half-written list of | |
| test cases. In particular, it's a list of inputs for the **A** parameter, and | |
| you're free to come up with your own inputs for the **B** parameter. For each | |
| given string **A**, you want to find a string **B** that will cause Ethan's | |
| algorithm to return the wrong output (`false` instead of `true`), if possible. | |
| **A** will only contain uppercase alphabetic characters, and **B** must follow | |
| the same constraint. The test cases shouldn't be too large, so **B** must also | |
| contain at most 10,000 characters. | |
| ### Input | |
| Input begins with an integer **T**, the number of given strings. Then, **T** | |
| lines follow. Each line contains a single string, **A**. | |
| ### Output | |
| For the _i_th given string, print a line containing "Case #_i_: " followed by | |
| any valid string **B** that will cause Ethan's algorithm to return the wrong | |
| value, or "Impossible" if no such string exists. | |
| ### Constraints | |
| 1 ≤ **T** ≤ 100 | |
| 1 ≤ |**A**| ≤ 2,000 | |
| ### Explanation of Sample | |
| In the first case, _i_ and _j_ will have these values in order the first 10 | |
| times the algorithm is at Step 2: | |
| i j | |
| --- | |
| 1 1 | |
| 2 2 | |
| 1 2 | |
| 1 3 | |
| 1 4 | |
| 1 5 | |
| 2 6 | |
| 3 7 | |
| 4 8 | |
| 1 8 | |
| Please note that other outputs for example cases 1 and 3 would also be | |
| accepted. | |