Arrangement of dimes to bring all heads Consider an arrangement of n dimes in a straight line. A move consists of taking a dime and turning it over (from head to tail or vice versa) and of doing the same to each of its neighbors. If the dime is at the end of the line, then it will have only one neighbor. For example, if the arrangement is HHTH and you choose the second dime, then your move would result in TTHH. The general question is this: Given any arrangement of n dimes, is it possible to find a sequence of moves to bring it to all heads?
 A: Not an answer, but too long for a comment.
I wrote this python script
import numpy as np
from scipy.sparse.csgraph import connected_components

for k in range(4,11):
    n=2**k
    masks =  {3}
    j=0
    while 7*2**j < n:
        masks.add(7*2**j)
        j+= 1
    masks.add(n//2+n//4)
    A = np.zeros((n,n), dtype = int)
    for i in range(n):
        for m in masks:
            A[i, i^m] = 1
    supernodes=connected_components(A)
    print(k, supernodes[0])

For $4\le k< 11,$ it computes the adjacency matrix of the graph whose vertices are the $k-$bit binary strings, where two vertices are adjacent if one can be transformed into the other by a single flip (substituting $1$'s and $0'$s for heads and tails, of course.)
Then it computes the connected components of the graph.  The problem is possible if and only if the number is one.  Here is the output: 
4 1
5 2
6 1
7 1
8 2
9 1
10 1

The script is very fast, so it can probably be used to determine what the pattern is. supernodes[1] is a list that encodes the components.  For example, when $k=5$ this list is
[0 1 1 0 0 1 1 0 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 0 1 1 0 0 1 1 0]
This means that TTTTT is in component $0$, TTTTH and TTTHT are in component $1,$ and so on.  Perhaps one might be able to find a pattern and prove that it is impossible in certain cases, but I'm dubious.  
The script bogs down considerably a $k$ increases.  I found that $k=11$ is the only other value below $14$ for which it's impossible.  I got bored waiting for the $k=14$ case to finish.   
EDIT 
I've checked that it's impossible for $n=14$ so now I'm willing to guess that it's possible except when $n\equiv2\pmod3$.  One thing I have verified which may be useful, is that in the impossible cases, there are exactly two connected components, and that if two strings different only in the last character, (or only in the first character, by symmetry) then it is impossible to transform one into the other.
So for example, when $n=5,$ every $4-$character string occurs as a prefix of one word in each component  So far, I haven't figured out how it is decided which components the five-character strings go in.  Here is component $0$:
['TTTTT', 'TTTHH', 'TTHTT', 'TTHHH', 'THTTH', 'THTHT', 'THHTH', 'THHHT', 'HTTTH', 'HTTHT', 'HTHTH', 'HTHHT', 'HHTTT', 'HHTHH', 'HHHTT', 'HHHHH']
and here is component $1$:
['TTTTH', 'TTTHT', 'TTHTH', 'TTHHT', 'THTTT', 'THTHH', 'THHTT', 'THHHH', 'HTTTT', 'HTTHH', 'HTHTT', 'HTHHH', 'HHTTH', 'HHTHT', 'HHHTH', 'HHHHT'] 
Given a five-character string over $\{H,T\}$ how can we decide which component it should go in without searching the components?
