#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-9;
const long double PI = atan(1) * 4;
const long long M = 1000000007;
struct PT {
  double x, y;
  PT() {}
  PT(double x, double y) : x(x), y(y) {}
  PT(const PT &p) : x(p.x), y(p.y) {}
  PT operator+(const PT &p) const { return PT(x + p.x, y + p.y); }
  PT operator-(const PT &p) const { return PT(x - p.x, y - p.y); }
  PT operator*(double c) const { return PT(x * c, y * c); }
  PT operator/(double c) const { return PT(x / c, y / c); }
};
double dot(PT p, PT q) { return p.x * q.x + p.y * q.y; }
double dist2(PT p, PT q) { return dot(p - q, p - q); }
double cross(PT p, PT q) { return p.x * q.y - p.y * q.x; }
double cos_u2v(const PT &u, const PT &v) {
  return dot(u, v) / sqrt(dot(u, u) * dot(v, v));
}
double sin_u2v(const PT &u, const PT &v) {
  return cross(u, v) / sqrt(dot(u, u) * dot(v, v));
}
ostream &operator<<(ostream &os, const PT &p) {
  os << "(" << p.x << "," << p.y << ")";
}
double vector2angle(const PT &v) { return atan2(v.y, v.x); }
struct UnionFind {
  vector<long long> C;
  UnionFind(long long n) : C(n) {
    for (int i = 0; i < n; i++) C[i] = i;
  }
  long long find(long long x) { return (C[x] == x) ? x : C[x] = find(C[x]); }
  void merge(long long x, long long y) { C[find(x)] = find(y); }
};
long long mod(long long x, long long m) { return ((x % m) + m) % m; }
long long gcd(long long a, long long b) {
  for (; b > 0; swap(a, b)) a %= b;
  return a;
}
long long extended_euclid(long long a, long long b, long long &x,
                          long long &y) {
  long long xx = y = 0;
  long long yy = x = 1;
  while (b) {
    long long q = a / b;
    long long t = b;
    b = a % b;
    a = t;
    t = xx;
    xx = x - q * xx;
    x = t;
    t = yy;
    yy = y - q * yy;
    y = t;
  }
  return a;
}
long long mod_inverse(long long a, long long n) {
  long long x, y;
  long long d = extended_euclid(a, n, x, y);
  if (d > 1) return -1;
  return mod(x, n);
}
struct LPSolver {
  int m, n;
  vector<long long> B, N;
  vector<vector<long double>> D;
  LPSolver(const vector<vector<long double>> &A, const vector<long double> &b,
           const vector<long double> &c)
      : m(b.size()),
        n(c.size()),
        N(n + 1),
        B(m),
        D(m + 2, vector<long double>(n + 2)) {
    for (int i = 0; i < m; i++)
      for (int j = 0; j < n; j++) D[i][j] = A[i][j];
    for (int i = 0; i < m; i++) {
      B[i] = n + i;
      D[i][n] = -1;
      D[i][n + 1] = b[i];
    }
    for (int j = 0; j < n; j++) {
      N[j] = j;
      D[m][j] = -c[j];
    }
    N[n] = -1;
    D[m + 1][n] = 1;
  }
  void Pivot(int r, int s) {
    for (int i = 0; i < m + 2; i++)
      if (i != r)
        for (int j = 0; j < n + 2; j++)
          if (j != s) D[i][j] -= D[r][j] * D[i][s] / D[r][s];
    for (int j = 0; j < n + 2; j++)
      if (j != s) D[r][j] /= D[r][s];
    for (int i = 0; i < m + 2; i++)
      if (i != r) D[i][s] /= -D[r][s];
    D[r][s] = 1.0 / D[r][s];
    swap(B[r], N[s]);
  }
  bool Simplex(int phase) {
    int x = phase == 1 ? m + 1 : m;
    while (true) {
      int s = -1;
      for (int j = 0; j <= n; j++) {
        if (phase == 2 && N[j] == -1) continue;
        if (s == -1 || D[x][j] < D[x][s] || D[x][j] == D[x][s] && N[j] < N[s])
          s = j;
      }
      if (D[x][s] > -EPS) return true;
      int r = -1;
      for (int i = 0; i < m; i++) {
        if (D[i][s] < EPS) continue;
        if (r == -1 || D[i][n + 1] / D[i][s] < D[r][n + 1] / D[r][s] ||
            (D[i][n + 1] / D[i][s]) == (D[r][n + 1] / D[r][s]) && B[i] < B[r])
          r = i;
      }
      if (r == -1) return false;
      Pivot(r, s);
    }
  }
  long double solve(vector<long double> &x) {
    int r = 0;
    for (int i = 1; i < m; i++)
      if (D[i][n + 1] < D[r][n + 1]) r = i;
    if (D[r][n + 1] < -EPS) {
      Pivot(r, n);
      if (!Simplex(1) || D[m + 1][n + 1] < -EPS)
        return -numeric_limits<long double>::infinity();
      for (int i = 0; i < m; i++)
        if (B[i] == -1) {
          int s = -1;
          for (int j = 0; j <= n; j++)
            if (s == -1 || D[i][j] < D[i][s] ||
                D[i][j] == D[i][s] && N[j] < N[s])
              s = j;
          Pivot(i, s);
        }
    }
    if (!Simplex(2)) return numeric_limits<long double>::infinity();
    x = vector<long double>(n);
    for (int i = 0; i < m; i++)
      if (B[i] < n) x[B[i]] = D[i][n + 1];
    return D[m][n + 1];
  }
};
void edgelist2adjlists(long long n, const vector<long long> &froms,
                       const vector<long long> &tos, vector<long long> &v2e0,
                       vector<long long> &e2n) {
  v2e0.resize(n);
  v2e0.assign(n, -1);
  long long en = froms.size();
  e2n.resize(en);
  for (int i = 0; i < en; i++) {
    long long f = froms[i];
    long long t = tos[i];
    e2n[i] = v2e0[f];
    v2e0[f] = i;
  }
}
struct FordFulk {
  const vector<long long> &v2e0;
  const vector<long long> &e2f;
  const vector<long long> &e2t;
  const vector<long long> &e2c;
  const vector<long long> &e2n;
  long long s, t;
  FordFulk(const vector<long long> &_v2e0, const vector<long long> &_e2f,
           const vector<long long> &_e2t, const vector<long long> &_e2c,
           const vector<long long> &_e2n, long long _s, long long _t)
      : s(_s), t(_t), v2e0(_v2e0), e2f(_e2f), e2t(_e2t), e2c(_e2c), e2n(_e2n) {}
  long long _find_aug_path(const vector<long long> &v2e0,
                           const vector<long long> &e2f,
                           const vector<long long> &e2t,
                           const vector<long long> &e2c,
                           const vector<long long> &e2n, long long s,
                           long long t, vector<long long> &epath) {
    vector<long long> q2v;
    vector<long long> q2p;
    vector<long long> q2e;
    vector<long long> q2f;
    vector<bool> inq(v2e0.size(), false);
    q2v.push_back(s);
    q2p.push_back(-1);
    q2e.push_back(-1);
    q2f.push_back(INT_MAX);
    inq[s] = true;
    for (long long i = 0; i < q2v.size(); i++) {
      long long crt = q2v[i];
      long long f = q2f[i];
      for (long long j = v2e0[crt]; j != -1; j = e2n[j]) {
        long long to = e2t[j];
        long long rem = e2c[j];
        if (inq[to]) continue;
        if (rem <= 0) continue;
        q2v.push_back(to);
        q2p.push_back(i);
        q2e.push_back(j);
        q2f.push_back(min(f, rem));
        inq[to] = true;
      }
    }
    for (long long i = 0; i < q2v.size(); i++) {
      if (q2v[i] != t) continue;
      stack<long long> stk;
      for (long long j = i; j > 0; j = q2p[j]) {
        stk.push(q2e[j]);
      }
      while (!stk.empty()) {
        epath.push_back(stk.top());
        stk.pop();
      }
      return q2f[i];
    }
    return 0;
  }
  long long eval() {
    long long en = e2f.size();
    map<pair<long long, long long>, long long> rsd;
    for (long long i = 0; i < en; i++) {
      long long f = e2f[i];
      long long t = e2t[i];
      rsd[make_pair(f, t)] += e2c[i];
      rsd[make_pair(t, f)] += 0;
    }
    map<pair<long long, long long>, long long> nei;
    long long ren = 0;
    for (auto er : rsd) {
      nei[er.first] = ren++;
    }
    long long rvn = v2e0.size();
    vector<long long> rv2e0(rvn, -1);
    vector<long long> re2f(ren);
    vector<long long> re2t(ren);
    vector<long long> re2c(ren);
    vector<long long> re2n(ren);
    vector<long long> re2p(ren);
    long long rei = 0;
    for (auto er : rsd) {
      long long f = er.first.first;
      long long t = er.first.second;
      long long c = er.second;
      re2f[rei] = f;
      re2t[rei] = t;
      re2c[rei] = c;
      re2p[rei] = nei[make_pair(t, f)];
      re2n[rei] = rv2e0[f];
      rv2e0[f] = rei;
      ++rei;
    }
    long long sol = 0;
    vector<long long> epath;
    while (true) {
      epath.clear();
      long long res =
          _find_aug_path(rv2e0, re2f, re2t, re2c, re2n, s, t, epath);
      if (res == 0) break;
      for (auto ei : epath) {
        re2c[ei] -= res;
        re2c[re2p[ei]] += res;
      }
      sol += res;
    }
    return sol;
  }
};
template <typename T>
struct LazySegTree1D {
  vector<T> v;
  vector<long long> opr;
  vector<T> opd;
  vector<long long> nxt;
  long long LEFT;
  long long RGHT;
  T (*fnx)(long long, T);
  T (*fab)(T, T);
  LazySegTree1D(long long _l, long long _r, T _v, T (*_fnx)(long long, T),
                T (*_fab)(T, T))
      : v(1), opr(1), opd(1), nxt(1), LEFT(_l), RGHT(_r), fnx(_fnx), fab(_fab) {
    v[0] = fnx(RGHT - LEFT + 1, _v);
    opr[0] = 0;
    opd[0] = _v;
    nxt[0] = -1;
  }
  void _split(long long i, long long l0, long long r0) {
    assert(nxt[i] == -1);
    assert(opr[i] == 0);
    assert(l0 < r0);
    long long n = v.size();
    nxt[i] = n;
    long long m0 = (l0 + r0) / 2;
    v.push_back(fnx(m0 - l0 + 1, opd[i]));
    v.push_back(fnx(r0 - m0, opd[i]));
    opr.push_back(0);
    opr.push_back(0);
    opd.push_back(opd[i]);
    opd.push_back(opd[i]);
    nxt.push_back(-1);
    nxt.push_back(-1);
  }
  void _pushdown(long long i, long long l0, long long r0) {
    if (opr[i] == -1) return;
    long long m0 = (l0 + r0) / 2;
    if (nxt[i] == -1)
      _split(i, l0, r0);
    else if (opr[i] >= 0) {
      _set(nxt[i], l0, m0, l0, m0, opr[i], opd[i]);
      _set(nxt[i] + 1, m0 + 1, r0, m0 + 1, r0, opr[i], opd[i]);
    }
    opr[i] = -1;
  }
  void _set(long long i, long long l0, long long r0, long long l1, long long r1,
            long long o1, T v1) {
    assert(l1 >= l0 && r1 <= r0);
    if (l0 == l1 && r0 == r1) {
      if (o1 == 0) {
        v[i] = fnx(r0 - l0 + 1, v1);
        opr[i] = 0;
        opd[i] = v1;
      } else if (o1 == 1) {
        v[i] = fab(v[i], fnx(r0 - l0 + 1, v1));
        if (opr[i] == -1) {
          opr[i] = 1;
          opd[i] = v1;
        } else if (opr[i] == 0) {
          opr[i] = 0;
          opd[i] = fab(opd[i], v1);
        } else if (opr[i] == 1) {
          opr[i] = 1;
          opd[i] = fab(opd[i], v1);
        }
      }
      return;
    }
    long long m0 = (l0 + r0) / 2;
    _pushdown(i, l0, r0);
    if (l1 <= m0) _set(nxt[i], l0, m0, l1, min(r1, m0), o1, v1);
    if (r1 > m0) _set(nxt[i] + 1, m0 + 1, r0, max(l1, m0 + 1), r1, o1, v1);
    v[i] = fab(v[nxt[i]], v[nxt[i] + 1]);
  }
  T _get(long long i, long long l0, long long r0, long long l1, long long r1) {
    assert(l0 <= l1 && r1 <= r0);
    if (l0 == l1 && r1 == r0) return v[i];
    _pushdown(i, l0, r0);
    long long m0 = (l0 + r0) / 2;
    if (r1 <= m0) return _get(nxt[i], l0, m0, l1, r1);
    if (m0 + 1 <= l1) return _get(nxt[i] + 1, m0 + 1, r0, l1, r1);
    T lv = _get(nxt[i], l0, m0, l1, m0);
    T rv = _get(nxt[i] + 1, m0 + 1, r0, m0 + 1, r1);
    return fab(lv, rv);
  }
  void updres(long long l1, long long r1, T v1) {
    _set(0, LEFT, RGHT, l1, r1, 1, v1);
  }
  void setval(long long l1, long long r1, T v1) {
    _set(0, LEFT, RGHT, l1, r1, 0, v1);
  }
  T get(long long l1, long long r1) { return _get(0, LEFT, RGHT, l1, r1); }
};
long long getmove(long long n, long long from, long long to) {
  long long c = ((to + n - from) % n);
  long long cc = ((from + n - to) % n);
  if (c < cc) return c;
  return -cc;
}
vector<long long> getpath0(long long n, vector<long long> &eles, long long from,
                           long long to) {
  vector<long long> ret;
  long long en = eles.size();
  while (from != to) {
    long long nxt = (from + 1) % en;
    ret.push_back(((eles[nxt] + n - eles[from]) % n));
    from = nxt;
  }
  return ret;
}
vector<long long> getpath1(long long n, vector<long long> &eles, long long from,
                           long long to) {
  vector<long long> ret;
  long long en = eles.size();
  while (from != to) {
    long long nxt = (from + en - 1) % en;
    ret.push_back(-((eles[from] + n - eles[nxt]) % n));
    from = nxt;
  }
  return ret;
}
vector<long long> convec(const vector<long long> &va,
                         const vector<long long> &vb) {
  vector<long long> ret(va);
  ret.insert(ret.end(), vb.begin(), vb.end());
  return ret;
}
long long getlocalcost(long long n, vector<long long> &eles, long long from,
                       long long to) {
  long long en = eles.size();
  long long topre = (to + en - 1) % en;
  long long tonxt = (to + 1) % en;
  long long c0 =
      ((eles[topre] + n - eles[from]) % n) + ((eles[topre] + n - eles[to]) % n);
  long long c1 =
      ((eles[from] + n - eles[tonxt]) % n) + ((eles[to] + n - eles[tonxt]) % n);
  return min(c0, c1);
}
vector<long long> getlocalpath(long long n, vector<long long> &eles,
                               long long from, long long to) {
  long long en = eles.size();
  if (en == 1) return vector<long long>(0);
  long long topre = (to + en - 1) % en;
  long long tonxt = (to + 1) % en;
  long long c0 =
      ((eles[topre] + n - eles[from]) % n) + ((eles[topre] + n - eles[to]) % n);
  long long c1 =
      ((eles[from] + n - eles[tonxt]) % n) + ((eles[to] + n - eles[tonxt]) % n);
  vector<long long> seq;
  vector<long long> dir;
  if (c0 <= c1) {
    for (long long i = from;; i = (i + 1) % en) {
      seq.push_back(eles[i]);
      if (i == topre) break;
      dir.push_back(0);
    }
    for (long long i = (from + en - 1) % en;; i = (i + en - 1) % en) {
      dir.push_back(1);
      seq.push_back(eles[i]);
      if (i == to) break;
    }
  } else {
    for (long long i = from;; i = (i + en - 1) % en) {
      seq.push_back(eles[i]);
      if (i == tonxt) break;
      dir.push_back(1);
    }
    for (long long i = (from + 1) % en;; i = (i + 1) % en) {
      dir.push_back(0);
      seq.push_back(eles[i]);
      if (i == to) break;
    }
  }
  vector<long long> ret;
  for (long long i = 1; i < seq.size(); i++)
    ret.push_back((dir[i - 1] == 0) ? ((seq[i] + n - seq[i - 1]) % n)
                                    : -((seq[i - 1] + n - seq[i]) % n));
  return ret;
}
void dijkstra(vector<long long> &v2e0, vector<long long> &e2t,
              vector<long long> &e2c, vector<long long> &e2n, long long src,
              vector<long long> &dist, vector<long long> &prec) {
  long long n = v2e0.size();
  dist.assign(n, INT_MAX);
  prec.assign(n, -1);
  vector<bool> arr(n);
  long long sel = src;
  dist[sel] = 0;
  while (sel >= 0) {
    arr[sel] = true;
    for (long long i = v2e0[sel]; i >= 0; i = e2n[i]) {
      long long to = e2t[i];
      long long cost = e2c[i];
      if (!arr[to] && dist[to] > dist[sel] + cost) {
        dist[to] = dist[sel] + cost;
        prec[to] = sel;
      }
    }
    sel = -1;
    for (long long i = 0; i < n; i++)
      if (!arr[i] && (sel == -1 || dist[i] < dist[sel])) sel = i;
  }
}
bool inseg(long long l, long long r, long long m) {
  if (l == r) return true;
  if (l < r) return l <= m && m < r;
  if (l > r) return m >= l || m < r;
}
long long discretize(vector<long long> &x) {
  set<long long> avset(x.begin(), x.end());
  map<long long, long long> vmap;
  long long dn = 0;
  for (auto it = avset.begin(); it != avset.end(); it++) vmap[*it] = dn++;
  for (long long i = 0, n = x.size(); i < n; i++) x[i] = vmap[x[i]];
  return dn;
}
int main() {
  long long n, p0;
  cin >> n >> p0;
  long long gvn = n * 2 + 2;
  p0--;
  vector<long long> a(n);
  for (long long i = 0; i < n; i++) cin >> a[i];
  long long bn = discretize(a);
  vector<vector<long long>> b2p(bn);
  for (long long i = 0; i < n; i++) b2p[a[i]].push_back(i);
  for (auto ps : b2p) sort(ps.begin(), ps.end());
  long long vn = 0;
  vector<long long> e2f;
  vector<long long> e2t;
  vector<long long> e2n;
  vector<long long> e2c;
  vector<long long> v2e0(gvn, -1);
  vector<long long> v2pos(gvn, -1);
  vector<long long> v2bi(gvn, -1);
  for (long long i = 0; i < bn; i++) {
    auto poss = b2p[i];
    long long pn = poss.size();
    for (long long j = 0; j < pn; j++)
      v2pos[vn + j] = v2pos[vn + pn + j] = poss[j];
    for (long long j = 0; j < pn; j++) v2bi[vn + j] = v2bi[vn + pn + j] = j;
    if (pn == 1) {
      {
        e2f.push_back(vn);
        e2t.push_back(vn + 1);
        e2c.push_back(0);
      };
    } else {
      for (long long j = 0; j < pn; j++)
        for (long long k = 0; k < pn; k++) {
          if (k == j) continue;
          long long cost = getlocalcost(n, poss, j, k);
          {
            e2f.push_back(vn + j);
            e2t.push_back(vn + pn + k);
            e2c.push_back(cost);
          };
        }
    }
    if (i < bn - 1) {
      auto nxtp = b2p[i + 1];
      long long nxtpsz = nxtp.size();
      if (nxtpsz == 1) {
        for (long long j = 0, k = 0; j < pn; j++) {
          e2f.push_back(vn + pn + j);
          e2t.push_back(vn + pn * 2);
          e2c.push_back(min(((nxtp[0] + n - poss[j]) % n),
                            ((poss[j] + n - nxtp[0]) % n)));
        };
      } else {
        for (long long j = 0, k = 0; j < pn; j++) {
          for (; !inseg(nxtp[k], nxtp[(k + 1) % nxtpsz], poss[j]);
               k = (k + 1) % nxtpsz)
            ;
          long long k1 = (k + 1) % nxtpsz;
          {
            e2f.push_back(vn + pn + j);
            e2t.push_back(vn + pn * 2 + k);
            e2c.push_back(((poss[j] + n - nxtp[k]) % n));
          };
          {
            e2f.push_back(vn + pn + j);
            e2t.push_back(vn + pn * 2 + k1);
            e2c.push_back(((nxtp[k1] + n - poss[j]) % n));
          };
        }
      }
    }
    vn += pn * 2;
  }
  v2pos[gvn - 2] = p0;
  long long k = 0, kn = b2p[0].size();
  for (; !inseg(b2p[0][k], b2p[0][(k + 1) % kn], p0); k = (k + 1) % kn)
    ;
  if (p0 == b2p[0][k]) {
    {
      e2f.push_back(gvn - 2);
      e2t.push_back(k);
      e2c.push_back(0);
    };
  } else {
    {
      e2f.push_back(gvn - 2);
      e2t.push_back(k);
      e2c.push_back(((p0 + n - b2p[0][k]) % n));
    };
    {
      e2f.push_back(gvn - 2);
      e2t.push_back((k + 1) % kn);
      e2c.push_back(((b2p[0][(k + 1) % kn] + n - p0) % n));
    };
  }
  auto lastposs = b2p.back();
  long long lastkn = lastposs.size();
  for (long long i = gvn - 2 - lastkn; i < gvn - 2; i++) {
    e2f.push_back(i);
    e2t.push_back(gvn - 1);
    e2c.push_back(0);
  };
  edgelist2adjlists(gvn, e2f, e2t, v2e0, e2n);
  vector<long long> prec(gvn, -1);
  vector<long long> dist(gvn, INT_MAX);
  dijkstra(v2e0, e2t, e2c, e2n, gvn - 2, dist, prec);
  stack<long long> solstk;
  for (long long i = prec[gvn - 1]; i != gvn - 2; i = prec[prec[i]]) {
    long long lo = i;
    long long li = prec[lo];
    auto zu = b2p[a[v2pos[li]]];
    auto lp = getlocalpath(n, zu, v2bi[li], v2bi[lo]);
    for (auto it = lp.rbegin(); it != lp.rend(); ++it) solstk.push(*it);
    long long gp = getmove(n, v2pos[prec[li]], v2pos[li]);
    solstk.push(gp);
  }
  cout << dist.back() << endl;
  for (; !solstk.empty();) {
    long long mv = solstk.top();
    solstk.pop();
    if (mv >= 0) cout << "+";
    cout << mv << endl;
  }
  return 0;
}
