#include <bits/stdc++.h>
using namespace std;
const int nsz = 2e3, inf = 0x3f3f3f3f;
int n, m, src, a[nsz + 5], g[nsz + 5], dp[nsz + 5][nsz + 5], ans = inf;
pair<int, int> fm[nsz + 5][nsz + 5];
vector<vector<int> > p;
struct event {
  char op;
  int d;
  event() {}
  event(char op, int d) : op(op), d(d) {}
};
vector<event> res;
int inline pre(vector<int> &a, int w) {
  vector<int>::iterator it = lower_bound(a.begin(), a.end(), w);
  return it == a.begin() ? a.back() : *(--it);
}
int inline nxt(vector<int> &a, int w) {
  vector<int>::iterator it = lower_bound(a.begin(), a.end(), w);
  return *it == a.back() ? *a.begin() : *(++it);
}
int inline dis(int u, int v) { return min(abs(u - v), n - abs(u - v)); }
int inline dir_dis(int u, int v) { return v - u < 0 ? v - u + n : v - u; }
bool inline upd(int &a, int b) {
  if (a > b) {
    a = b;
    return 1;
  }
  return 0;
}
void inline solve() {
  memset(dp, inf, sizeof(dp));
  dp[0][src] = 0;
  p[0].push_back(src);
  for (int c = 1; c <= m; ++c) {
    vector<int> &p = ::p[c], &q = ::p[c - 1];
    memset(g, inf, sizeof(g));
    for (int i = 0; i < p.size(); ++i)
      for (int j = 0; j < q.size(); ++j) {
        if (upd(g[p[i]], dp[c - 1][q[j]] + dis(p[i], q[j])))
          fm[c][p[i]].first = q[j];
      }
    for (int i = 0; i < p.size(); ++i) {
      int cur = p[i], pre = ::pre(p, p[i]), nxt = ::nxt(p, p[i]);
      int pre_w = n - dir_dis(pre, cur), nxt_w = n - dir_dis(cur, nxt);
      int pre_d = +1, nxt_d = -1;
      if (p.size() <= 2) {
        if (upd(pre_w, n - pre_w)) pre_d *= -1;
        if (upd(nxt_w, n - nxt_w)) nxt_d *= -1;
      }
      if (upd(dp[c][pre], g[cur] + pre_w)) fm[c][pre].second = cur * pre_d;
      if (upd(dp[c][nxt], g[cur] + nxt_w)) fm[c][nxt].second = cur * nxt_d;
    }
  }
  int u = -1;
  for (int i = 1; i <= n; ++i) {
    if (upd(ans, dp[m][i])) u = i;
  }
  for (int c = m; c >= 1; --c) {
    pair<int, int> p = fm[c][u];
    int w = u, v = abs(p.second), d = p.second / v;
    if (d == -1) {
      for (int w1 = u, w2 = nxt(::p[c], w1), k = 0; k + 1 < ::p[c].size();
           w1 = w2, w2 = nxt(::p[c], w2), ++k) {
        res.push_back(event('-', dir_dis(w1, w2)));
      }
    } else if (d == +1) {
      for (int w1 = u, w2 = pre(::p[c], w1), k = 0; k + 1 < ::p[c].size();
           w1 = w2, w2 = pre(::p[c], w2), ++k) {
        res.push_back(event('+', dir_dis(w2, w1)));
      }
    }
    u = fm[c][v].first;
    int dir = u < v ? +1 : -1, dis = abs(v - u);
    if (n - dis < dis) dir *= -1, dis = n - dis;
    res.push_back(event(dir == -1 ? '-' : '+', dis));
  }
  reverse(res.begin(), res.end());
}
void inline discretize() {
  static int b[nsz + 5];
  for (int i = 1; i <= n; ++i) b[m++] = a[i];
  sort(b, b + m), m = unique(b, b + m) - b;
  p.resize(m + 1);
  for (int i = 1; i <= n; ++i)
    a[i] = lower_bound(b, b + m, a[i]) - b + 1, p[a[i]].push_back(i);
}
int main() {
  scanf("%d%d", &n, &src);
  for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
  discretize();
  solve();
  printf("%d\n", ans);
  for (int i = 0; i < res.size(); ++i) printf("%c %d\n", res[i].op, res[i].d);
}
