| 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. |
|
|
|
|
