#include <iostream>
#include <vector>
#include <bitset>
#include <valarray>
#include <cmath>
using namespace std;

// only works for T = signed int
//                    signed double
template <typename T>
class universal_mod {
  const T m;
public:
  universal_mod(const T& base): m(base) {}
  T operator()(T x) const {
    x -= m*int(x/m);
    x += m*(x<0);
    return x;
  }
};

template <typename T, size_t N>
class Ring {
  valarray<T> v;
  universal_mod<int> ring;

  friend ostream& operator<<(ostream& os, Ring& item) {
    for (int i=0; i!=item.size(); ++i)
      os << (item[i]? "#": "-") << " ";
    return os;
  }
public:
  Ring(): v(T(),N),ring(N) {}
  T& operator[](int i) {
    return v[ring(i)];
  }
  Ring& operator=(const Ring& rhs) { v=rhs.v; return *this; }
  int size() const { return N; }
};

// stochastic engine
class Glauber {
  const double beta;
  double prob(const double& dE) const {
    return (1-tanh(beta*dE/2))/2.0;
  }
public:
  Glauber(double T): beta(1.0/T) {}
  bool binary_signal(const double& dE) const {
    const double p = prob(dE);
    return rand()/(1.0+RAND_MAX) < p;
  }
} engine(4*atan(1.0));

// particle tossing machine
class Machine {
  bool state; // ACTIVE=true, SLEEP=false
public:
  Machine(): state(true) {}
  bool is_active() const { return state; }
  void excite() { state = true; }
  void sleep() { state = false; }
} machine;

int main()
{
  srand(time(NULL));

  const int N = 40;
  Ring<bool,N> f;
  for (int i=0; i!=N/2; ++i)
    f[i]=true;

  for (int t=0; t!=0xFF; ++t) {
    cout << f << endl;
    // Begin Sweep
    int i=N; while (i!=0) {
      --i;
      if (f[i] && !f[i+1] && machine.is_active() && engine.binary_signal(1.0)) {
        f[i] = false;
        f[i+1] = true;
        machine.sleep();
        //cout << "Hopped from " << i << " to " << i+1 << endl;
      }
      else
        machine.excite();
    } // End Sweep
  }
  return 0;
}