The following pattern works with $31$ weighings:
$${0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, \
0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, \
0, 1, 1, 1}.$$
This beats the $35$-weighing solution found earlier.
$${1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, \
1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, \
0, 0, 0, 1}.$$ See the comments at the end of this post.
This is not a complete answer, but it won't fit in a comment. We define $f(n)$ to be the smallest number of weighings possible for $n$ coins. Here is some simple but not particularly efficient Mathematica code which computes $f(n)$ for small $n$ by brute force: pick a representative $x$ of a rotational equivalence class of $n$-long $\{0,1\}$-vectors, build a matrix out of $k$ successive rotations of $x$, hit that matrix against all $\{0,1\}$-vectors, and see if all $2^n$ results are distinct. There are roughly $2^n/n$ rotation classes, so the complexity of this is about $4^n/n$.
(* check if vector x works when rotated k times *)
ok[x_, k_] := Block[{n = Length[x], m, v},
m = RotateRight[x, #] & /@ Range[k];
v = Tuples[{0, 1}, n];
Unequal @@ (m.# & /@ v)];
(* compute a canonical representative for the rotation class of x *)
MinRotation[x_] :=
First[Sort[RotateRight[x, #] & /@ Range[Length[x]]]];
f[n_] := f[n] = Block[{k, v},
v = Select[Tuples[{0, 1}, n], # == MinRotation[#] &];
For[k = 1, k <= n, k++,
s = Select[v, ok[#, k] &];
If[s != {}, Return[{k, First[s], Length[s]}]]]];
TableForm[Prepend[f[#], #] & /@ Range[12],
TableDirections -> {Column, Row, Row},
TableHeadings -> {None, {"n", "f(n)", "Example", "# of examples"}}]
$$
\begin{array}{cccc}
\text{n} & \text{f(n)} & \text{Example} & \text{$\#$ of examples} \\
1 & 1 & (1) & 1 \\
2 & 2 & (0 1) & 1 \\
3 & 3 & (0 0 1) & 2 \\
4 & 3 & (0 1 1 1) & 1 \\
5 & 4 & (0 0 1 1 1) & 3 \\
6 & 5 & (0 0 1 0 1 1) & 4 \\
7 & 6 & (0 0 0 0 1 1 1 & 12 \\
8 & 6 & (0 0 0 1 0 1 0 1) & 8 \\
9 & 6 & (0 0 1 0 0 1 0 1 1) & 6 \\
10 & 7 & (0 0 0 0 1 1 0 1 1 1) & 17 \\
11 & 7 & (0 0 0 1 0 1 0 0 1 1 1) & 4 \\
12 & 8 & (0 0 0 0 1 0 0 0 1 0 1 1) & 42 \\
\end{array}$$
This quickly becomes infeasible. However, checking a given vector costs "only" $2^n$ matrix multiplies, so we can get some upper bounds for $f(n)$ by guessing good vectors $x$. A reasonable heuristic is that the $k\times n$ matrix $A$ we're constructing should have $\det A A^T$ large; using that, we find for example that $f(15)\le 9$, since
$$(0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1)$$
turns out to work with $9$ rotations.
(Added 7/3/2015:)
To construct the solutions for $k=31$ and $k=35$ weighings of $n=50$ coins, I started by running a hill-climb about $3$ times, and picked the pattern giving the largest $\det AA^T$. As a first check, I looked at a reduced basis for $\ker A$ to check that it didn't have any nonzero vectors whose coordinates were at most $1$ in absolute value, and then exhaustively checked $\ker A$ by putting it into Hermite form first. This requires checking about $(2/3)3^{n-k}$ vectors, which is easy on a laptop. The run for $k=31$ took about $7$ hours, $81$ times as long as the run for $k=35$.
Incidentally, just from a visual examination of the reduced bases for smaller values of $k$, I suspect that $f(50)$ is about $28$.
