#if !defined(__clang__) && defined(__GNUC__) && !defined(LOCAL)
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#endif
#if !defined(LOCAL)
#include <algorithm>
#include <array>
#include <atcoder/maxflow>
#include <atcoder/string>
#include <bit>
#include <chrono>
#include <compare>
#include <concepts>
#include <execution>
#include <fstream>
#include <iostream>
#include <limits>
#include <map>
#include <numbers>
#include <numeric>
#include <print>
#include <random>
#include <ranges>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#elif 1
#include <pch.h>
#else
import std;
#endif
namespace inner {
// clang-format off
#define c_ constexpr
#define t_ template
std::vector<bool> isprime_seq(size_t size){std::vector<bool> ret(size+size%2+2);ret[0]=ret[1]=0;ret[2]=1;for(size_t i=3;i<ret.size();i+=2)ret[i]=1;for(size_t i=3;i<ret.size();i+=2){if(ret[i])for(size_t j=i*2;j<ret.size();j+=i)ret[j]=0;}return ret;}
t_<class T = int64_t> struct ratio {
  T n;T d;
  c_ ratio(T n_,T d_):n(n_/std::gcd(n_,d_)),d(d_/std::gcd(n_,d_)){}c_ ratio(T n_):n(n_),d(1){}
  #define o_(o,...) c_ ratio& operato##o(const ratio& r){*this={__VA_ARGS__};return *this;}
  o_(r+=,n*r.d+d*r.n,r.d*d);o_(r-=,n*r.d-d*r.n,r.d*d);o_(r*=,n*r.n,r.d*d);o_(r/=,n*r.d,r.d*n);
  #undef o_
  #define o_(o) c_ ratio operato##o(const ratio& y)const{ratio r=*this;o##=y;return r;}
  o_(r+);o_(r-);o_(r*);o_(r/);
  #undef o_
};
namespace ｺﾝｾﾌﾟ{
t_<class F,class R,class... T>concept func=std::is_invocable_r_v<R,F,T...>;
};
t_<class T,auto e_>
c_ T segtree_id();
t_<class T,ｺﾝｾﾌﾟ::func<T,T,T>auto op,auto e_>
struct segtree{std::vector<T>v;size_t sz;static inline T e=segtree_id<T,e_>();
#define SEGTREE_BODY \
c_ segtree(){}\
c_ segtree(size_t sz_):v(std::bit_ceil(sz_)*2,e),sz(std::bit_ceil(sz_)){}\
c_ segtree(std::initializer_list<T>v){init(v);}\
t_<std::ranges::range R>c_ segtree(const R& v_){init(v_);}\
t_<std::ranges::range R>c_ void init(const R& v_){using namespace std::ranges;sz=std::bit_ceil(size(v_));v.resize(std::bit_ceil(sz*2));copy(v_,v.begin()+sz);fill(v|views::drop(size(v_)),e);auto sz_=sz/2;while(sz_!=0){for(size_t i=sz_;i<sz_*2;i++){v[i]=op(v[2*i+1],v[2*i]);}sz_/=2;}}\
c_ T prod(size_t l,size_t r)const{l+=sz;r+=sz;T l_=e,r_=e;while(l<r){if(l%2)l_=op(l_,v[l++]);if(r%2)r_=op(v[--r],r_);l/=2;r/=2;}return op(l_,r_);}\
c_ const T& get(size_t i){return v[i+sz];}\
c_ const T& operator[](size_t i){return get(i);}\
c_ void set(size_t i,T v){i+=sz;v[i]=v;while(i/=2){v[i]=op(v[i*2],v[i*2|1]);}}\
c_ size_t size(){return sz;}
SEGTREE_BODY};
t_<class T,ｺﾝｾﾌﾟ::func<T,T,T>auto op,auto e_>requires requires{segtree_id<T,e_()>();}
struct segtree<T,op,e_>{std::vector<T>v;size_t sz;c_ static T e=segtree_id<T,e_>();SEGTREE_BODY};
t_<class T,auto op,std::convertible_to<T>auto e_>
c_ T segtree_id(){return e_;}
t_<class T,auto op,ｺﾝｾﾌﾟ::func<T>auto e_>
c_ T segtree_id(){return e_();}
#undef SEGTREE_BODY
int main();
#undef c_
// clang-format on
}  // namespace inner
int main() {
  using namespace std;
  using namespace std::chrono;
  ios::sync_with_stdio(false);
  cout.precision(10);
#ifdef LOCAL
  ifstream in("case.txt");
  int n;
  in >> n;
  if (n > 0) {
    cin.rdbuf(in.rdbuf());
    for (int i = 0; i < n; i++) {
      cout << "\n----test case " << i << "----" << endl;
      auto t0 = high_resolution_clock::now();
      inner::main();
      auto t1 = high_resolution_clock::now();
      cout << format("\n\n{},{}", i, t1 - t0) << endl;
    }
  } else if (n < 0) {
  } else {
    inner::main();
  }
  return 0;
#else
  inner::main();
  return 0;
#endif
}
using namespace inner;
using std::cin, std::cout;
#define main inner::main
#include <algorithm>
#include <iostream>
#include <vector>

int main() {
  int N, T;
  cin >> N >> T;
  std::vector<int> A(N);
  for (auto& a : A) cin >> a;
  std::vector<int64_t> mins(T + 11, 1ll << 60);
  mins[A[0]] = 0;
  std::vector<int64_t> mins_(T + 11);
  for (int i = 1; i < N; i++) {
    for (auto& a : mins_) a = 1ll << 60;
    for (int j = 0; j <= T; j++) {
      if (mins[j] == 1ll << 60) continue;
      if (j + A[i] <= T) mins_[j + A[i]] = std::min(mins_[j + A[i]], mins[j] * 2);
      if (j * A[i] <= T) mins_[j * A[i]] = std::min(mins_[j * A[i]], mins[j] * 2 + 1);
    }
    swap(mins, mins_);
  }
  for (int i = 1; i < N; i++) {
    cout << (mins[T] & (1 << (N - i - 1)) ? '*' : '+');
  }
  cout << '\n';
  return 0;
}