#include <bits/stdc++.h>
using namespace std;

#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define all(x) begin(x), end(x)
#define sz(x) int((x).size())
using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;

#ifdef LOCAL
auto operator<<(auto& o, auto x) -> decltype(x.first, o);
auto operator<<(auto& o, auto x) -> decltype(x.end(), o) {
  o << "{";
  for (int i = 0; auto y : x) o << ", " + !i++ * 2 << y;
  return o << "}";
}
auto operator<<(auto& o, auto x) -> decltype(x.first, o) {
  return o << "(" << x.first << ", " << x.second << ")";
}
void __print(auto... x) { ((cerr << x << " "), ...) << endl; }
#define debug(x...) __print("[" #x "]:", x)
#else
#define debug(...) 2137
#endif

using db = double;

int main() {
  cin.tie(0)->sync_with_stdio(0);
  int n;
  cin >> n;
  vector<pair<db, int>> v(n + 1);

  for(int i = 1; i <= n; i++) {
    cin >> v[i].first;
    v[i].second = i;
  }

  sort(1 + all(v));

  const db inf = 1e9;

  // [l; r]
  vector dp(n + 1, vector(n + 1, db(inf)));
  
  vector suma(n + 1, db(0));

  for(int i = 1; i <= n; i++)
    suma[i] = v[i].first;

  for(int i = 1; i <= n; i++)
    suma[i] += suma[i - 1];

  auto daj = [&](int l, int r) -> db {
    db prawa = suma[r];
    db lewa = suma[l - 1];
    debug(l, r, prawa, lewa, prawa - lewa, suma);
    return prawa - lewa;
  };

  debug(suma);

  vector kto(n + 1, vector(n + 1, -1));
  vector side(n + 1, vector(n + 1, -1));

  for(int i = 1; i <= n; i++)
    dp[i][i] = 0;

  function<db(int, int)> f = [&] (int l, int r) -> db {
    if(l > r)
      return 0;
    if(dp[l][r] < inf)
      return dp[l][r];

    for(int mid = l; mid < r; mid++) {
      db lewa = f(l, mid);
      db prawa = f(mid + 1, r);
      db l0 = daj(l, mid);
      db l1 = daj(mid + 1, r);

      db w1 = lewa + prawa + l0 * 2 + l1 * 1;

      if(w1 < dp[l][r]) {
        dp[l][r] = w1;
        kto[l][r] = mid;
        side[l][r] = 0;
      }

      db w2 = lewa + prawa + l0 * 1 + l1 * 2;

      if(w2 < dp[l][r]) {
        dp[l][r] = w2;
        kto[l][r] = mid;
        side[l][r] = 1;
      }
      
      debug(l, r, mid, w1, w2, l0, l1);

    }

    return dp[l][r];

  };

  f(1, n);

  vector<pair<int, string>> ans(n + 1);

  function<void(int, int)> rec = [&] (int l, int r) {
    if(l >= r)
      return;

    debug(l, r, dp[l][r], kto[l][r], side[l][r]);
    //fflush(stderr);

    int mid = kto[l][r];
    assert(mid != -1);

    rec(l, mid);
    rec(mid + 1, r);
    vector<string> pref = {"-", "."};
    if(side[l][r])
      swap(pref[0], pref[1]);

    for(int i = l; i <= mid; i++)
      ans[i].second = pref[0] + ans[i].second;
    
    for(int i = mid + 1; i <= r; i++)
      ans[i].second = pref[1] + ans[i].second;
  };

  debug(v);
  debug(dp);
  debug(kto);
  debug(side);

  rec(1, n);

  debug(ans);

  for(int i = 1; i <= n; i++)
    ans[i].first = v[i].second;

  sort(all(ans));

  for(int i = 1; i <= n; i++)
    cout << ans[i].second << endl;

  

}

/*
^[[A^[[Ateam52@FEP-PC14126:~/contest/d$ ./sol < in1
[suma]: {0, 0.25, 0.55, 1} 
[l, r, prawa, lewa, prawa - lewa, suma]: 2 2 0 0 0 {0, 0.25, 0.55, 1} 
[l, r, prawa, lewa, prawa - lewa, suma]: 3 3 1 0 1 {0, 0.25, 0.55, 1} 
[l, r, mid, w1, w2, l0, l1]: 2 3 2 1 2 0 1 
[l, r, prawa, lewa, prawa - lewa, suma]: 1 1 0 0 0 {0, 0.25, 0.55, 1} 
[l, r, prawa, lewa, prawa - lewa, suma]: 2 3 1 0 1 {0, 0.25, 0.55, 1} 
[l, r, mid, w1, w2, l0, l1]: 1 3 1 2 3 0 1 
[l, r, prawa, lewa, prawa - lewa, suma]: 1 1 0 0 0 {0, 0.25, 0.55, 1} 
[l, r, prawa, lewa, prawa - lewa, suma]: 2 2 0 0 0 {0, 0.25, 0.55, 1} 
[l, r, mid, w1, w2, l0, l1]: 1 2 1 0 0 0 0 
[l, r, prawa, lewa, prawa - lewa, suma]: 1 2 0 0 0 {0, 0.25, 0.55, 1} 
[l, r, prawa, lewa, prawa - lewa, suma]: 3 3 1 0 1 {0, 0.25, 0.55, 1} 
[l, r, mid, w1, w2, l0, l1]: 1 3 2 1 2 0 1 
[v]: {(0, 0), (0.25, 3), (0.3, 1), (0.45, 2)} 
[dp]: {{1e+09, 1e+09, 1e+09, 1e+09}, {1e+09, 0, 0, 1}, {1e+09, 1e+09, 0, 1}, {1e+09, 1e+09, 1e+09, 0}} 
[kto]: {{-1, -1, -1, -1}, {-1, -1, 1, 2}, {-1, -1, -1, 2}, {-1, -1, -1, -1}} 
[side]: {{-1, -1, -1, -1}, {-1, -1, 0, 0}, {-1, -1, -1, 0}, {-1, -1, -1, -1}} 
[l, r, dp[l][r], kto[l][r], side[l][r]]: 1 3 1 2 0 
[l, r, dp[l][r], kto[l][r], side[l][r]]: 1 2 0 1 0 
[ans]: {(0, ), (0, --), (0, -.), (0, .)} 
-.
.
--


*/