Costas array of order 32 or 33

Download the artifact, parse the permutation, and normalize to 1-based indexing if it is given 0-based. Check it is a genuine permutation of 1..n. Then compute all C(n,2) displacement vectors and check they are pairwise distinct:
      p = normalize_to_1_based(load_permutation(path))
      n = len(p)
      seen = set()
      for i in range(n):
        for j in range(i+1, n):
          disp = (j - i, p[j] - p[i])
          if disp in seen:
            FAIL: duplicate displacement (i, j)
          seen.add(disp)
    This is O(n^2), at most a few hundred thousand pairs even at n=33, trivial to run. Compare n to the claimed tier: only n=30 counts as target and only n=32 or 33 as record, so also sanity-check that n is exactly one of those values before crediting the higher tiers. A dishonest or broken submission typically resembles a known construction with two entries swapped (which almost always breaks the distinct-displacement property) or was checked only on adjacent-row pairs instead of every pair of rows.

Background: a Costas array of order n is a permutation p of {1,...,n}, thought of as n
dots on an n x n grid with exactly one dot per row and per column (dot in row i sits at
column p[i]). It must satisfy a "distinct displacement" property: for every pair of rows
i<j, the displacement vector (j-i, p[j]-p[i]) is unique among all C(n,2) such pairs. This
property (no two pairs of dots have the same relative offset) is what makes Costas arrays
useful for radar and sonar waveform design, and gives the family its name (after J. P.
Costas).

Two classical families of algebraic constructions are known. The Welch construction works
when n = p-1 for a prime p (with variants also giving n = p-2 and n = p-3). The
Lempel-Golomb construction works when n = q-2 for a prime power q (with variants giving
n = q-3, and in special cases n = q-4 or n = q-5). Combining these and other known families,
a Costas array is known for every order up to 31, and exhaustive enumeration (counting all
Costas arrays of a given order, not just finding one) has been completed up to about order
29. As of this writing, orders 32 and 33 are the smallest orders for which no Costas array
is known to exist, and none has been proven not to exist either: this is an open problem.

A Golomb-type construction over the finite field GF(32) (using q=32=2^5, a prime power)
gives a Costas array of order 30, which is the target tier for this mission.

Artifact format: a permutation of 1..n on a single line, values separated by spaces or
commas, e.g. "2 4 1 3". A JSON array such as [2,4,1,3] is also accepted. 0-based
permutations (values 0..n-1) are auto-detected and normalized to 1-based internally, so
either convention is fine as long as it is used consistently. Row i (1-indexed) is
understood to hold its dot in column p[i]. Tiny valid example, order 3: "1 3 2" places dots
at (row 1, col 1), (row 2, col 3), (row 3, col 2); its three displacement vectors, (1,2),
(2,1) and (1,-1), are all distinct, so it is a valid (if tiny) Costas array.

Tiers: valid = any correctly verified Costas array with n < 30 (score = n). target = n >= 30
except n = 32 or 33 (this matches, for example, the known GF(32) construction giving
n=30). record = n = 32 or n = 33: an actual Costas array at either of these currently open
orders would be a genuinely new result. The tier is decided by which order class n falls
into, not simply by comparing score to a threshold, because a larger n is not automatically
more significant here: constructions are already known for most orders, and 32/33 are the
specific unresolved cases that matter.

Attack strategies:
1. Implement the Welch and/or Lempel-Golomb constructions over a prime or prime power of
   your choice and verify them against several known orders up to 31; this is a reliable way
   to reach valid and target tiers, including the GF(32)-based order-30 construction.
2. For the open record target (n=32 or n=33): checking a candidate permutation costs only
   O(n^2) (496 or 528 pairs), so local search is cheap. Try simulated annealing or tabu
   search that minimizes the number of colliding displacement vectors, starting either from
   random permutations or from small perturbations (transpositions) of known constructions
   for nearby orders. Exhaustive or backtracking search with symmetry reduction (the grid's
   dihedral symmetries: reflection and 180-degree rotation preserve the Costas property) can
   also help prune the search space.
3. Check whether a Costas array of order 32 or 33 has been published since these notes were
   written; retrieving and correctly transcribing a genuine published construction is a
   completely legitimate way to solve the open part of this mission.

Pitfalls: the distinct-displacement property must hold for every one of the C(n,2) pairs of
rows, not just adjacent rows -- a common bug is only checking pairs (i, i+1). Off-by-one
errors between 0-based and 1-based indexing are common; this verifier accepts either
convention but always compares against a consistently indexed permutation, so pick one
convention and stick with it within a single submission. A permutation that merely
resembles a known construction (e.g. a Welch array with two entries swapped) will almost
always break the Costas property; always self-check with a brute-force O(n^2) verifier
before submitting. Submissions with n > 200 are rejected outright.