結果
| 問題 | No.2426 Select Plus or Minus |
| ユーザー |
 namakoiscat
|
| 提出日時 | 2023-08-18 21:54:33 |
| 言語 | C++17 (gcc 12.3.0 + boost 1.83.0) |
| 結果 |
WA
|
| 実行時間 | - |
| コード長 | 24,799 bytes |
| コンパイル時間 | 3,899 ms |
| コンパイル使用メモリ | 252,724 KB |
| 実行使用メモリ | 5,376 KB |
| 最終ジャッジ日時 | 2024-05-06 03:54:20 |
| 合計ジャッジ時間 | 5,870 ms |
|
ジャッジサーバーID （参考情報） |
judge2 / judge3 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 2 ms
5,248 KB |
| testcase_01 | AC | 2 ms
5,376 KB |
| testcase_02 | AC | 2 ms
5,376 KB |
| testcase_03 | AC | 2 ms
5,376 KB |
| testcase_04 | AC | 2 ms
5,376 KB |
| testcase_05 | WA | - |
| testcase_06 | AC | 2 ms
5,376 KB |
| testcase_07 | AC | 2 ms
5,376 KB |
| testcase_08 | AC | 2 ms
5,376 KB |
| testcase_09 | AC | 2 ms
5,376 KB |
| testcase_10 | AC | 2 ms
5,376 KB |
| testcase_11 | AC | 2 ms
5,376 KB |
| testcase_12 | AC | 1 ms
5,376 KB |
| testcase_13 | AC | 2 ms
5,376 KB |
| testcase_14 | AC | 2 ms
5,376 KB |
| testcase_15 | AC | 2 ms
5,376 KB |
| testcase_16 | WA | - |
| testcase_17 | WA | - |
| testcase_18 | WA | - |
| testcase_19 | AC | 2 ms
5,376 KB |
| testcase_20 | AC | 1 ms
5,376 KB |
| testcase_21 | AC | 2 ms
5,376 KB |
| testcase_22 | WA | - |
| testcase_23 | WA | - |
| testcase_24 | AC | 2 ms
5,376 KB |
| testcase_25 | AC | 2 ms
5,376 KB |
| testcase_26 | AC | 2 ms
5,376 KB |
| testcase_27 | AC | 1 ms
5,376 KB |
| testcase_28 | AC | 2 ms
5,376 KB |
| testcase_29 | AC | 2 ms
5,376 KB |
| testcase_30 | AC | 2 ms
5,376 KB |
| testcase_31 | AC | 2 ms
5,376 KB |
| testcase_32 | AC | 2 ms
5,376 KB |
| testcase_33 | AC | 2 ms
5,376 KB |
| testcase_34 | AC | 2 ms
5,376 KB |
| testcase_35 | AC | 2 ms
5,376 KB |
| testcase_36 | AC | 1 ms
5,376 KB |
| testcase_37 | AC | 2 ms
5,376 KB |
| testcase_38 | AC | 2 ms
5,376 KB |
| testcase_39 | AC | 1 ms
5,376 KB |
| testcase_40 | AC | 1 ms
5,376 KB |
| testcase_41 | AC | 2 ms
5,376 KB |
| testcase_42 | AC | 1 ms
5,376 KB |
| testcase_43 | WA | - |
ソースコード
/*
#include <bits/stdc++.h>
using namespace std;
int main(){
ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
*/
// __builtin_popcountll() ;
// multiset ;
// unordered_set ;
// unordered_map ;
// reverse ;
// substr
// assert
// to_string
/*
#include <atcoder/all>
using namespace atcoder ;
// using mint = modint;
// using mint = modint998244353 ;
// using mint = modint1000000007 ;
*/
#include <bits/stdc++.h>
using namespace std;
/*
#include<boost/multiprecision/cpp_int.hpp>
using namespace boost::multiprecision;
typedef cpp_int cp ;
cp cp_mod0 = 1000000007 ;
cp cp_mod1 = 998244353 ;
cp cp_binpower(cp a, cp b ,cp c){
if(b == 0)return 1 ;
a %= c ;
cp d = cp_binpower(a,b/2,c) ;
(d *= d) %= c ;
if(b%2) (d *= a) %= c ;
return d ;
}
cp cp_powpow(cp A, cp B){
if(B == 0)return 1 ;
if(B == 1)return A ;
cp res = 1 ;
for(cp i = 1 ;i <= B ;i ++)res *= A ;
return res ;
}
string cp_10_to_2(cp X){
string abc = "" ;
if(X == 0)return "0" ;
while(X > 0){
abc = char(X%2 + '0') + abc ;
X /= 2 ;
}
return abc ;
}
cp cp_2_to_10(string moji){
cp abc = 0 ;
cp K = moji.size() ;
for(long long i = 0 ; i < K ; i++){
long long x = moji[i] - '0' ;
abc = abc * 2 + cp(x) ;
}
return abc ;
}
*/
//-------型-------
typedef long long ll;
typedef string st ;
typedef long double ld ;
typedef unsigned long long ull ;
using P = pair<ll,ll> ;
using Edge = tuple<ll,ll,ll> ;
using AAA = tuple<ll,ll,ll,ll> ;
//-------型-------
//-------定数-------
const ll mod0 = 1000000007;
const ll mod1 = 998244353 ;
const ll LINF = 1000000000000000000+2 ; //(10^18) + 2
const ld pai = acos(-1) ;
const ld EPS = 1e-10 ;
//-------定数-------
//-------マクロ-------
#define pb push_back
#define ppb pop_back
#define pf push_front
#define ppf pop_front
#define all(x) x.begin(), x.end()
#define rep(i,a,n) for (ll i = a; i <= (n); ++i)
#define rrep(i,a,b,c) for (ll i = a ; i <= (b) ; i += c)
#define ketu(i,a,n) for (ll i = a; i >= (n); --i)
#define re return 0;
#define fore(i,a) for(auto &i:a)
#define V vector
#define fi first
#define se second
#define C cout
#define E "\n";
#define EE endl;
//-------マクロ-------
//-------テンプレ文字列-------
st zz = "abcdefghijklmnopqrstuvwxyz" ;
st ZZ = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" ;
st tintin = "%" ;
st Y = "Yes" ;
st YY = "No" ;
st KU = " " ;
//-------テンプレ文字列-------
void chmin(ll& x ,ll y){x = min(x,y) ;}
void chmax(ll& x ,ll y){x = max(x,y) ;}
vector<ll> Y4 = {0,1,0,-1} ;
vector<ll> X4 = {1,0,-1,0} ;
vector<ll> Y8 = {0,1,1,1,0,-1,-1,-1} ;
vector<ll> X8 = {1,1,0,-1,-1,-1,0,1} ;
ll max_element(V<ll> &A){
ll res = *max_element(all(A)) ;
return res ;
}
ll max_element_index(V<ll> &A){
ll res = max_element(all(A)) - A.begin() ;
return res ;
}
ll min_element(V<ll> &A){
ll res = *min_element(all(A)) ;
return res ;
}
ll min_element_index(V<ll> &A){
ll res = min_element(all(A)) - A.begin() ;
return res ;
}
ll Random_Number(ll a , ll b){
random_device rd ;
mt19937 gen(rd()) ;
uniform_int_distribution<ll> dis(a,b);
ll res = dis(gen) ;
return res ;
}
ll sum_V(V<ll> A){
ll N = A.size() ;
ll res = 0 ;
rep(i,0,N-1){
res += A[i] ;
}
return res ;
}
ll sum_D(deque<ll> A){
deque<ll> B = A ;
ll res = 0 ;
while(!B.empty()){
ll pos = B.front() ;
B.ppf() ;
res += pos ;
}
return res ;
}
ll sum_Q(queue<ll> Q){
queue<ll> B = Q ;
ll res = 0 ;
while(!B.empty()){
ll pos = B.front() ;
B.pop() ;
res += pos ;
}
return res ;
}
ll k_lcm(V<ll> A){
ll res = 1 ;
ll N = A.size() ;
rep(i,0,N-1){
ll ans ;
ll K = A[i] / gcd(res,A[i]) ;
bool p = __builtin_smulll_overflow(res,K,&ans) ;
if(p == true)return -1 ;
else res = res * K ;
}
return res ;
}
ll k_gcd(V<ll> A){
ll N = A.size() ;
ll res = 0 ;
rep(i,0,N-1){
res = gcd(res,A[i]) ;
}
return res ;
}
V<ll> sort_erase_unique(V<ll> &A){
sort(all(A)) ;
A.erase(unique(all(A)),A.end()) ;
return A ;
}
ll powpow(ll A , ll B){
if(B == 0)return 1 ;
if(B == 1)return A ;
ll res = 1 ;
rep(i,1,B){
res *= A ;
}
return res ;
}
ll kiriage(ll a , ll b){
return (a + b - 1) / b ;
}
ll Permutation(ll N){
if(N == 0)return 1 ;
ll res = 1 ;
rep(i,1,N)res *= i ;
return res ;
}
V<st> String_Next_Permutation(st N){
sort(all(N)) ;
ll M = N.size() ;
ll Size = Permutation(M) ;
V<st> res(Size) ;
ll count = 0 ;
do{
rep(i,0,M-1){
res[count].pb(N[i]) ;
}
count ++ ;
}while(next_permutation(N.begin(),N.end()));
return res ;
}
V<V<ll>> Vector_Next_Permutation(V<ll> A){
ll Size = Permutation(A.size()) ;
V<V<ll>> res(Size) ;
ll count = 0 ;
do{
fore(u,A){
res[count].pb(u) ;
}
count ++ ;
}while(next_permutation(A.begin(),A.end()));
return res ;
}
P is_lower_and_upper(char c){
ll id = 0;
ll index = 0 ;
if(islower(c)){id = 1 ; index = c - 'a' ; }
if(isupper(c)){id = 2 ; index = c - 'A' ; }
return {id,index} ;
}
st Sub(st A,ll l , ll r){
st res ;
rep(i,l,r){
res += A[i] ;
}
return res ;
}
ll Arithmetic_Sequence(ll l , ll r){
ll res = 0 ;
if(l == 0)l ++ ;
if(l == r)return l ;
res += r*(r+1)/2 ;
res -= l*(l-1)/2 ;
return res ;
}
template<typename T>
V<T> array_sub(V<T> A,ll l , ll r){
V<T> res ;
rep(i,l,r){
res.pb(A[i]) ;
}
return res ;
}
template<typename T>
V<T> sr(V<T> A){
sort(all(A)) ;
reverse(all(A)) ;
return A ;
}
template<typename T>
V<T> shift_left(V<T> A, ll k){
ll N = A.size() ;
k %= N ;
V<T> res(N) ;
rep(i,0,N-1){
res[i] = A[(i+k)%N] ;
}
return res ;
}
template<typename T>
V<T> shift_right(V<T> A , ll k){
ll N = A.size() ;
k %= N ;
V<T> res(N) ;
rep(i,0,N-1){
res[i] = A[(i-k+N)%N] ;
}
return res ;
}
template<typename T>
void debag_1V_kaigyou(V<T> A){
ll N = A.size() ;
rep(i,0,N-1){
C << A[i] << E
}
}
template<typename T>
void debag_1V_space(V<T> A){
ll N = A.size() ;
rep(i,0,N-1){
C << A[i] << KU ;
}
C << E
}
void debag_2V(V<V<ll>> A){
ll N = A.size() ;
rep(i,0,N-1){
ll M = A[i].size() ;
rep(j,0,M-1){
if(A[i][j] == LINF || A[i][j] == -LINF)C << "L" << KU ;
else C << A[i][j] << KU ;
}
C << E
}
}
template<typename T>
void debag_2V_other(V<V<T>> A){
ll N = A.size() ;
rep(i,0,N-1){
ll k = A[i].size() ;
rep(j,0,k-1){
C << A[i][j] << KU ;
}
C << E
}
}
void debag_pair(V<P> A){
ll N = A.size() ;
rep(i,0,N-1){
auto [a,b] = A[i] ;
C << a << KU << b << E
}
}
void debag_Edge(V<Edge> A){
ll N = A.size() ;
rep(i,0,N-1){
auto [a,b,c] = A[i] ;
C << a << KU << b << KU << c << E
}
}
V<P> sort_Args(int len, ...)
{
V<ll> arr;
va_list args;
va_start(args, len);
for (int i = 0; i < len; ++i)
{
ll arg = va_arg(args, ll);
arr.push_back(arg);
}
va_end(args);
sort(arr.begin(), arr.end());
V<P> pos ;
pos.pb({0,-LINF}) ;
ll index = 1 ;
rep(i,0,len-1){
pos.pb({index,arr[i]}) ;
index ++ ;
}
return pos ;
}
ll a_up(V<ll> &A , ll x){
if(A[A.size()-1] < x)return -1 ;
ll res = lower_bound(all(A),x) - A.begin() ;
return A[res] ;
}
ll b_down(V<ll> &B , ll x){
if(B[0] > x)return -1 ;
ll res = upper_bound(all(B),x) - B.begin() ;
return B[res-1] ;
}
/*
st Regex(st S, st A ,st B){
return regex_replace(S,regex(A),B) ;
}
st erase_string(st S , st T){
st ans = S.erase(S.find(T),T.length()) ;
return ans ;
}
*/
ll pow_daisyou(ll a , ll b , ll c){
ll d = c%2==1 ? 1 : 2 ;
ll ans = -1 ;
if(powpow(a,d) == powpow(b,d))ans = 0 ;
if(powpow(a,d) > powpow(b,d))ans = 1 ;
else if(powpow(a,d) < powpow(b,d))ans = 2 ;
return ans ;
}
template<class T> T pow_mod(T A, T N, T M) {
T res = 1 % M;
A %= M;
while (N) {
if (N & 1) res = (res * A) % M;
A = (A * A) % M;
N >>= 1;
}
return res;
}
// Miller-Rabin 素数判定
bool nis(ll N) {
if (N <= 1) return false;
if (N == 2) return true;
if (N == 3) return true ;
if (N == 5) return true ;
if (N == 7) return true ;
if (N == 11) return true ;
if (N % 2 == 0 || N % 3 == 0 || N % 5 == 0 || N % 7 == 0 || N % 11 == 0 ) return false ;
vector<ll> A = {2, 325, 9375, 28178, 450775,9780504, 1795265022};
ll s = 0, d = N - 1;
while (d % 2 == 0) {
++s;
d >>= 1;
}
fore(a,A) {
if (a % N == 0) return true;
ll t, x = pow_mod<__int128_t>(a, d, N);
if (x != 1) {
for (t = 0; t < s; ++t) {
if (x == N - 1) break;
x = __int128_t(x) * x % N;
}
if (t == s) return false;
}
}
return true;
}
// UF.initはいっかいだけならいいけど、二回目以降はrepで初期化
vector<ll> par;
class UnionFind {
public:
// サイズをＧＥＴ！
void init(ll sz) {
par.resize(sz,-1);
}
// 各連結成分の一番上を返す
ll root(ll x) {
if (par[x] < 0) return x;
return par[x] = root(par[x]);
}
// 結合作業
bool unite(ll x, ll y) {
x = root(x); y = root(y);
if (x == y) return false;
if (par[x] > par[y]) swap(x,y);
par[x] += par[y];
par[y] = x;
return true;
}
// 同じグループか判定
bool same(ll x, ll y) { return root(x) == root(y);}
// グループのサイズをＧＥＴ！
ll size(ll x) { return -par[root(x)];}
};
UnionFind UF ;
vector<ll> enumdiv(ll n) {
vector<ll> S;
for (ll i = 1; i*i <= n; i++) if (n%i == 0) { S.pb(i); if (i*i != n) S.pb(n / i); }
sort(S.begin(), S.end());
return S;
}
template<typename T> using min_priority_queue = priority_queue<T, vector<T>, greater<T>>;
template<typename T> using max_priority_queue = priority_queue<T, vector<T>, less<T>> ;
// 使用例 min_priority_queue<ll (ここは型)> Q ;
template<typename T> using max_multiset = multiset<T, greater<T>>;
vector<pair<long long, long long>> prime_factorize(long long N){
vector<pair<long long, long long>> res;
for(long long a = 2; a * a <= N; ++a){
if(N % a != 0) continue;
long long ex = 0;
while(N % a == 0) ++ex, N /= a;
res.push_back({a,ex});
}
if(N != 1) res.push_back({N,1});
return res;
}
ll binpower(ll a, ll b,ll c) {
if(!b) return 1 ;
a %= c ;
ll d = binpower(a,b/2,c) ;
(d *= d) %= c ;
if(b%2) (d *= a) %= c ;
return d ;
}
map<ll,ll> Compression(V<ll> A){
sort(all(A)) ;
A.erase(unique(all(A)),A.end()) ;
map<ll,ll> res ;
ll index = 0 ;
fore(u,A){
res[u] = index ;
index ++ ;
}
return res ;
}
struct sqrt_machine{
V<ll> A ;
const ll M = 1000000 ;
bool p = false ;
void init(){
p = true ;
A.pb(-1) ;
rep(i,1,M){
A.pb(i*i) ;
}
A.pb(LINF) ;
}
bool scan(ll a){
if(p == false)init() ;
ll pos = lower_bound(all(A),a) - A.begin() ;
if(A[pos] == -1 || A[pos] == LINF || A[pos] != a)return false ;
return true ;
}
};
sqrt_machine SM ;
ll a_b(V<ll> A,ll a,ll b){
ll res = 0 ;
res += upper_bound(all(A),b) - lower_bound(all(A),a) ;
return res ;
}
struct era{
ll check[10000010] ;
bool p = false ;
void init(){
p = true ;
rep(i,2,10000000){
if(check[i] == 0){
for(ll j = i + i ;j <= 10000000 ; j += i){
check[j] ++ ;
}
}
}
}
bool look(ll x){
if(p == false)init() ;
if(x == 1)return false ;
if(check[x] == 0)return true ;
else return false ;
}
ll enu_count(ll x){
if(p == false)init() ;
if(x == 1)return 1 ;
if(check[x] == 0)return 1 ;
return check[x] ;
}
};
era era ;
st _10_to_2(ll x){
st abc = "" ;
if(x == 0){
return "0" ;
}
while(x > 0){
abc = char(x%2 + '0') + abc ;
x /= 2 ;
}
return abc ;
}
ll _2_to_10(st op){
ll abc = 0 ;
ll K = op.size() ;
for(ll i = 0 ;i < K ;i++){
abc = abc * 2 + ll(op[i] - '0') ;
}
return abc ;
}
V<tuple<char,ll,ll,ll>> Run_Length_Encoding(st S){
ll N = S.size() ;
V<tuple<char,ll,ll,ll>> A ;
ll count = 0 ;
char cc ;
bool RLEflag = false ;
ll l = 0 ;
ll r = 0 ;
if(N == 1){
A.pb({S[0],1,0,0}) ;
RLEflag = true ;
}
rep(i,0,N-1){
if(RLEflag == true)break ;
if(i == 0){
cc = S[i] ;
count = 1 ;
l = 0 ;
r = 0 ;
continue ;
}
r ++ ;
if(i == N-1){
if(S[i] == cc){
A.pb({cc,count + 1,l,N-1}) ;
}else{
A.pb({cc,count,l,N-2}) ;
A.pb({S[i],1,N-1,N-1}) ;
}
break ;
}
if(S[i] == cc){
count ++ ;
}else{
A.pb({cc,count,l,r-1}) ;
cc = S[i] ;
count = 1 ;
l = i ;
r = i ;
}
}
return A ;
}
V<tuple<ll,ll,ll,ll>> Run_Length_Encoding_Vector(V<ll> A){
ll N = A.size() ;
V<tuple<ll,ll,ll,ll>> res ;
ll count = 0 ;
ll cc = 0 ;
bool RLEflag = false ;
ll l = 0 ;
ll r = 0 ;
if(N == 1){
res.pb({A[0],1,0,0}) ;
RLEflag = true ;
}
rep(i,0,N-1){
if(RLEflag == true)break ;
if(i == 0){
cc = A[i] ;
count = 1 ;
l = 0 ;
r = 0 ;
continue ;
}
r ++ ;
if(i == N-1){
if(A[i] == cc){
res.pb({cc,count+1,l,N-1}) ;
}else{
res.pb({cc,count,l,N-2}) ;
res.pb({A[i],1,N-1,N-1}) ;
}
break ;
}
if(A[i] == cc){
count ++ ;
}else{
res.pb({cc,count,l,r-1}) ;
cc = A[i] ;
count = 1 ;
l = i ;
r = i ;
}
}
return res ;
}
bool Palindrome_Judgement(st S){
ll l = 0 ;
ll r = S.size() - 1 ;
bool flag = true ;
while(1){
if(S[l] != S[r])flag = false ;
l ++ ;
r -- ;
if(r < l)break ;
}
return flag ;
}
ll n_to_10(st S,ll n){
return stoll(S,nullptr,n) ;
}
/*
初期化 BiCoef<mint> bc(N) ;
mod0かmod1か選ぶ
出来ること
i! ====> bc.fact(i) ;
(1/i!) ====> bc.finv(i) ;
bc.com(n,k) ====> bc.com(n,k) ;
1/i ====> bc.inv(i) ;
*/
// modint
template<int MOD> struct Fp {
long long val;
constexpr Fp(long long v = 0) noexcept : val(v % MOD) {
if (val < 0) val += MOD;
}
constexpr int getmod() const { return MOD; }
constexpr Fp operator - () const noexcept {
return val ? MOD - val : 0;
}
constexpr Fp operator + (const Fp& r) const noexcept { return Fp(*this) += r; }
constexpr Fp operator - (const Fp& r) const noexcept { return Fp(*this) -= r; }
constexpr Fp operator * (const Fp& r) const noexcept { return Fp(*this) *= r; }
constexpr Fp operator / (const Fp& r) const noexcept { return Fp(*this) /= r; }
constexpr Fp& operator += (const Fp& r) noexcept {
val += r.val;
if (val >= MOD) val -= MOD;
return *this;
}
constexpr Fp& operator -= (const Fp& r) noexcept {
val -= r.val;
if (val < 0) val += MOD;
return *this;
}
constexpr Fp& operator *= (const Fp& r) noexcept {
val = val * r.val % MOD;
return *this;
}
constexpr Fp& operator /= (const Fp& r) noexcept {
long long a = r.val, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b, swap(a, b);
u -= t * v, swap(u, v);
}
val = val * u % MOD;
if (val < 0) val += MOD;
return *this;
}
constexpr bool operator == (const Fp& r) const noexcept {
return this->val == r.val;
}
constexpr bool operator != (const Fp& r) const noexcept {
return this->val != r.val;
}
friend constexpr istream& operator >> (istream& is, Fp<MOD>& x) noexcept {
is >> x.val;
x.val %= MOD;
if (x.val < 0) x.val += MOD;
return is;
}
friend constexpr ostream& operator << (ostream& os, const Fp<MOD>& x) noexcept {
return os << x.val;
}
friend constexpr Fp<MOD> modpow(const Fp<MOD>& r, long long n) noexcept {
if (n == 0) return 1;
if (n < 0) return modpow(modinv(r), -n);
auto t = modpow(r, n / 2);
t = t * t;
if (n & 1) t = t * r;
return t;
}
friend constexpr Fp<MOD> modinv(const Fp<MOD>& r) noexcept {
long long a = r.val, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b, swap(a, b);
u -= t * v, swap(u, v);
}
return Fp<MOD>(u);
}
};
// Binomial coefficient
template<class T> struct BiCoef {
vector<T> fact_, inv_, finv_;
constexpr BiCoef() {}
constexpr BiCoef(int n) noexcept : fact_(n, 1), inv_(n, 1), finv_(n, 1) {
init(n);
}
constexpr void init(int n) noexcept {
fact_.assign(n, 1), inv_.assign(n, 1), finv_.assign(n, 1);
int MOD = fact_[0].getmod();
for(int i = 2; i < n; i++){
fact_[i] = fact_[i-1] * i;
inv_[i] = -inv_[MOD%i] * (MOD/i);
finv_[i] = finv_[i-1] * inv_[i];
}
}
constexpr T com(int n, int k) const noexcept {
if (n < k || n < 0 || k < 0) return 0;
return fact_[n] * finv_[k] * finv_[n-k];
}
constexpr T fact(int n) const noexcept {
if (n < 0) return 0;
return fact_[n];
}
constexpr T inv(int n) const noexcept {
if (n < 0) return 0;
return inv_[n];
}
constexpr T finv(int n) const noexcept {
if (n < 0) return 0;
return finv_[n];
}
};
// const int MOD = mod0 ;
const int MOD = mod1 ;
using mint = Fp<MOD> ;
int main(void){
ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
//------------ちょっとした省略系---------------
// -----------数列-----------------------------
// max_element(V<ll> A) Aの最大値を返す
// max_element_index(V<ll> A) Aの最大値のindex
// min_element(V<ll> A) Aの最小値を返す
// min_element_index(V<ll> A) Aの最小値のindex
// array_sub(V<ll> A , ll l , ll r) 配列でやる
// V<V<ll>> Vector_Next_Permutation配列Aでやる
// sort_erase_unique(V<ll> A) sortしてeraseしてuniqueする関数
// sr(V<ll> A) 配列を入れたら、sort --→ reverse して返してくれる関数 受け取りは auto とかで
// sum_V , sum_D , sum_Q vector , deque , queue の和を返す関数
// shift_right(V<T> A, ll k) 数列を右にk個shiftする
// shift_left(V<T> A , ll k) 数列を左にk個shiftする
// -----------数列-----------------------------
// -----------文字列---------------------------
// is_lower_and_upper(char c) 小文字、大文字なんでも変換 小文字 = 1 , 大文字 = 2 pair型
// V<V<char>> String_Next_Permutation(st N) stringでnext_permutation
// Sub(st S,ll l , ll r) 文字列Sのl文字目からr文字目
// -----------文字列---------------------------
// -----------数字-----------------------------
// gcd(ll a , ll b) gcd(a,b) ;
// lcm(ll a ,ll b ) lcm
// k_lcm k個のlcm返す関数 空なら 1 、0なら0 、 overflowなら-1
// k_gcd(V<ll> A) k個のgcd返す関数
// Random_Number(ll a , ll b) [a,b]からランダムな数を返す関数 2*10^5 回やると大体1secぐらい
// powpow(ll a,ll b) a^b を返す
// kiriage(ll a , ll b) a 割られる数 b 割る数
// Permutation(ll N) N!の値を返す。20までならオーバーフローしない。
// Arithmetic_Sequence(ll l , ll r) [l,r]の等差数列の和
// -----------数字-----------------------------
//------------ちょっとした省略系---------------
//-----------debag系---------------------------
// debag_1V_kaigyou(V<ll> A) 一次元配列の中身を改行区切りで出力する
// debag_1V_space(V<ll> A) 一次元配列Aの中身をspace区切りで出力する
// debag_2V(V<V<ll>> A) 2次元配列Aの中身を返す関数
// debag_2V_other(V<V<T>> A) 2次元配列Aの中身を返す関数
// debag_pair(V<P> A) pair型配列の中身を出力する
// debag_Edge(V<Edge> A) Edge型配列の中身を出力する
// V<P> sort_Args(len,a,b,c) 個数を指定して、その個数だけ変数を渡し、昇順にして返す。1-indexになってる。
//-----------debag系---------------------------
// ---------いつ使うの？-----------------------
// a_b(A,a,b) [a,b]の個数 ---→ upper_bound(all(A),b) - lower_bound(all(A),a) ;
// Regex(st S, st A , st B) SのAをBに変えた文字列を返す 使う場合は消す
// erase_string(st S , st T) Sの中のTを消す
// a_up(V<ll> A , ll x) sort済み配列でｘ以上の最小値を返す。ない場合、-1を返す.
// b_down(V<ll> B , ll x)sort済み配列でx以下で最大値を返す。ない場合 -1を返す。
// pow_daisyou(ll a, ll b , ll c )a^cとb^cを比較する 0 => 同値 1 => a側 2=> ｂ側
// ---------いつ使うの？-----------------------
//------------アルゴリズム系-------------------
// nis(ll a) 素数判定 素数ならtrue
// UF UF.init(ll N) ; UF.root(i) ; UF.unite(a,b) ; UF.same(a,b) ; UF.size(i) ;
// enumdiv(ll a ) 約数列挙
// binpower(a,b,c) aのb条 をｃでわったやつをO(logb) でだしてくれるやつ
// Compression(V<ll> A) 座圧したmapを返す関数
// SM.scan(ll a) で 平方数ならtrue が返ってくる。 範囲は √10^6まで SM.init() 必ず起動する。
// era.look(ll a) --→ true 素数 / era.enu_count(ll a) --→ 素因数の個数 1は1 、素数も1 その他はそのまんま 範囲は10^7まで
// Run_Length_Encoding(st S) ランレングス圧縮して配列を返す tuple<char,ll,ll,ll> (S[i],length,l,r)
// Run_Length_Encoding_Vector(V<ll> A) 数列版のRLE tuple<ll,ll,ll,ll>
// prime_factorize(ll p) aのb乗のかたちででてくる 配列で受け取る
// Palindrome_Judgement(st S) 回分判定
// _10_to_2(ll x) 10進数を二進数にして返す。文字列で出力する事に注意 ll --→ st
// _2_to_10(st a) 2進数を10進数にして返す。 st --→ ll
// n_to_10(st S,ll n) n進数を10進数に直す
//------------アルゴリズム系-------------------
// (double)clock()/CLOCKS_PER_SEC>1.987
// mod0 --→ 1000000007 mod1 --→ 998244353 最初はmod1になってるので、注意
// S.substr(i,k) = [i,i+k) = [i,i+k-1]
// A~Z 65~90 a~z 97~122 V<char> には'\0'が初期値
// V<V<ll>> dp(N+1,V<ll>(N+1,LINF)) ;
// V<V<V<ll>>> dp(N+1,V<V<ll>>(2,V<ll>(2,LINF))) ;
ll N ;
cin >> N ;
ll count = 0 ;
V<st> ans ;
while(N != 1){
if(N % 2 == 0){N /= 2 ; ans.pb("/") ;}
else{
N = 3*N + 1 ;
ans.pb("+") ;
}
}
C << ans.size() << E
fore(u,ans)C << u ;
// if(dx < 0 || dy < 0 || dx >= W || dy >= H) continue ;
// C << fixed << setprecision(10) << // 勝手に四捨五入してくれてるから安心して
re
}