| /*@ Import Lean | |
| import Algorithms.minimal_representation.lean.spec_lib | |
| open scoped SimpleC | |
| */ | |
| /* | |
| * Find the lexicographically smallest cyclic rotation of an integer sequence. | |
| * | |
| * The sequence is copied twice into b so that every cyclic rotation is | |
| * represented by one contiguous segment. The two-candidate scan eliminates | |
| * at least one possible starting position after every mismatch, and therefore | |
| * runs in linear time. | |
| * | |
| * The verification case limits n to 1000. The caller provides n initialized | |
| * elements in a, room for 2 * n elements in b, and room for n elements in out. | |
| * The function writes the smallest rotation to out and returns its zero-based | |
| * starting position in a. | |
| */ | |
| /*@ Extern Coq | |
| (MRRotation : list Z -> Z -> list Z) | |
| (MRFirstMinimalRotationAt : list Z -> Z -> Prop) | |
| */ | |
| int minimal_representation(int *a, int n, int *b, int *out) | |
| /*@ With (l : list Z) (best : Z) | |
| Require | |
| 1 <= n && n <= 1000 && | |
| Zlength(l) == n && | |
| 0 <= best && best < n && | |
| MRFirstMinimalRotationAt(l, best) && | |
| IntArray::full(a, n, l) * | |
| IntArray::undef_full(b, 2 * n) * | |
| IntArray::undef_full(out, n) | |
| Ensure | |
| exists bl, | |
| __return == best && | |
| MRFirstMinimalRotationAt(l, __return) && | |
| IntArray::full(a, n, l) * | |
| IntArray::full(b, 2 * n, bl) * | |
| IntArray::full(out, n, MRRotation(l, __return)) | |
| */ | |
| { | |
| int p = 0; | |
| while (p < n) { | |
| b[p] = a[p]; | |
| b[n + p] = a[p]; | |
| ++p; | |
| } | |
| int i = 0; | |
| int j = 1; | |
| int k = 0; | |
| while (i < n && j < n) { | |
| k = 0; | |
| while (k < n && b[i + k] == b[j + k]) { | |
| ++k; | |
| } | |
| if (k == n) { | |
| break; | |
| } | |
| if (b[i + k] > b[j + k]) { | |
| i = i + k + 1; | |
| if (i == j) { | |
| ++i; | |
| } | |
| } | |
| else { | |
| j = j + k + 1; | |
| if (i == j) { | |
| ++j; | |
| } | |
| } | |
| } | |
| if (i < j) { | |
| p = i; | |
| } | |
| else { | |
| p = j; | |
| } | |
| k = 0; | |
| while (k < n) { | |
| out[k] = b[p + k]; | |
| ++k; | |
| } | |
| return p; | |
| } | |