Problem:
C: Not Found
問題
文字
0
,
1
からなる長さ $n$ の相異なる文字列が $m$ 個与えられるので、以下の条件をすべて満たす文字列 $t$ を構築せよ。
$t$ は
0
,
1
,
*
のみからなる長さ $n$ の文字列である
$t$ に含まれる
0
と
1
の個数の合計は $20$ 以下である
$t$ 中の文字
*
を
0
または
1
にどのように置き換えても、全ての $1 \leq i \leq m$ に対して，与えられた $i$ 番目の文字列 $s_i$ と $t$ が一致することはない
入力形式
$n$ $m$
$s_1$
...
$s_m$
制約
$1 \leq n$
$1 \leq m < 2^n$
$n \times m \leq 2500000$
$|s_i| = n$ ($1 \leq i \leq m$)
$s_i \neq s_j$ ($1 \leq i < j \leq m$)
$s_i$ は
0
,
1
のみからなる ($1 \leq i \leq m$)
出力形式
条件を満たす文字列を一行に出力せよ。条件を満たすものであれば何を出力しても構わない。条件を満たす文字列が存在しない場合は
hokudai
と出力せよ。
入力例1
3 2
101
000
出力例1
*1*
各
*
を
0
とみても
1
とみても
101
や
000
に一致することはありません。
入力例2
2 3
11
10
00
出力例2
01

Submitted solutions:

code_snippet: #include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 9223372036854775807
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;


#define SIZE 2500005
#define MAX 20

int N,M;
int POW[MAX+1];
bool check[SIZE][2],used[1<<20];
string line[SIZE];

int main(){

	POW[0] = 1;
	for(int i = 1; i <= MAX; i++){

		POW[i] = POW[i-1]*2;
	}

	scanf("%d %d",&N,&M);

	for(int i = 0; i < N; i++){
		for(int k = 0; k < 2; k++){
			check[i][k] = false;
		}
	}

	for(int i = 0; i < M; i++){

		cin >> line[i];
		for(int k = 0; k < line[i].length(); k++){
			check[k][line[i][k]-'0'] = true;
		}
	}

	for(int i = 0; i < N; i++){
		for(int k = 0; k < 2; k++){
			if(!check[i][k]){
				for(int a = 0; a < i; a++){
					printf("*");
				}
				printf("%d",k);
				for(int a = i+1; a < N; a++){
					printf("*");
				}
				printf("\n");
				return 0;
			}
		}
	}

	for(int i = 0; i < POW[min(MAX,N)]; i++){

		used[i] = false;
	}

	for(int i = 0; i < M; i++){

		int tmp = 0;
		for(int k = 0; k < min(MAX,N); k++){

			tmp = 2*tmp+(line[i][k]-'0');
		}
		used[tmp] = true;
	}

	for(int i = 0; i < POW[min(MAX,N)]; i++){
		if(!used[i]){

			int tmp = i;
			for(int k = min(MAX,N)-1; k >= 0; k--){
				if(POW[k] <= tmp){
					tmp -= POW[k];
					printf("1");

				}else{

					printf("0");
				}
			}
			if(MAX < N){
				int diff = N-MAX;
				for(int a = 0; a < diff; a++){
					printf("*");
				}
			}
			printf("\n");
			return 0;
		}
	}

	printf("hokudai\n");

	return 0;
}
accuracy: 0.036585365853658534
time_ms: 50
memory_kb: 91288
final_rank: 19

code_snippet: #include <bits/stdc++.h>
//#include<atcoder/modint>
//using namespace atcoder;
using namespace std;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vvvb = vector<vvb>;
using vd = vector<double>;
using vvd = vector<vd>;
using vvvd = vector<vvd>;
#define all(A) A.begin(),A.end()
#define rep(i, n) for (ll i = 0; i < (ll) (n); i++)
template<class T>
bool chmax(T& p, T q, bool C = 1) {
    if (C == 0 && p == q) {
        return 1;
    }
    if (p < q) {
        p = q;
        return 1;
    }
    else {
        return 0;
    }
}
template<class T>
bool chmin(T& p, T q, bool C = 1) {
    if (C == 0 && p == q) {
        return 1;
    }
    if (p > q) {
        p = q;
        return 1;
    }
    else {
        return 0;
    }
}
ll modPow(long long a, long long n, long long p) {
    if (n == 0) return 1; // 0乗にも対応する場合
    if (n == 1) return a % p;
    if (n % 2 == 1) return (a * modPow(a, n - 1, p)) % p;
    long long t = modPow(a, n / 2, p);
    return (t * t) % p;
}
ll cnt = 0;
ll gcd(ll(a), ll(b)) {
    cnt++;
    if (a == 0)return b;
    if (b == 0)return a;
    ll c = a;
    while (a % b != 0) {
        c = a % b;
        a = b;
        b = c;
    }
    return b;
}
ll sqrtz(ll N) {
    ll L = 0;
    ll R = sqrt(N) + 10000;
    while (abs(R - L) > 1) {
        ll mid = (R + L) / 2;
        if (mid * mid <= N)L = mid;
        else R = mid;
    }
    return L;
}

using LD = long double;

/*
using mint = modint1000000007;
using vm = vector<mint>;
using vvm = vector<vm>;
using vvvm = vector<vvm>;


vector<mint> fact, factinv, inv;
const ll mod = 1e9+7;
void prenCkModp(ll n) {
    fact.resize(n + 5);
    factinv.resize(n + 5);
    inv.resize(n + 5);
    fact[0] = fact[1] = 1;
    factinv[0] = factinv[1] = 1;
    inv[1] = 1;
    for (ll i = 2; i < n + 5; i++) {
        fact[i] = (fact[i - 1] * i);
        inv[i] = (mod - ((inv[mod % i] * (mod / i))));
        factinv[i] = (factinv[i - 1] * inv[i]);
    }
}
mint nCk(ll n, ll k) {
    if (n < k || k < 0) return 0;
    return (fact[n] * ((factinv[k] * factinv[n - k])));
}
*/

int main() {

    cin.tie(nullptr);
    ios::sync_with_stdio(false);

    ll N,M;
    cin>>N>>M;
    vector<string> S(M);
    rep(i,M)cin>>S[i];
    vector<bool> L(M,1);
    ll t=N;
    rep(i,min(ll(20),N)){
        vll A(2,0);
        rep(m,M){
            if(!L[m])continue;
            A[S[m][i]-'0']++;
        }
        char p=(A[0]<A[1]?'0':'1');
        cout<<p;
        rep(m,M){
            if(L[m]&&S[m][i]!=p)L[m]=0;
        }
        t--;
    }
    rep(i,t)cout<<"*";
    cout<<endl;
}
accuracy: 1
time_ms: 30
memory_kb: 11228
final_rank: 6

code_snippet: #include <bits/stdc++.h>
using namespace std;
using ll = long long;

int main() {
    int N, M; cin >> N >> M;
    vector<string> S(M);
    for(int i = 0; i < M; i++) cin >> S[i];

    sort(S.begin(), S.end());

    string t;
    int L = 0, R = M;
    for(int i = 0; i < 20; i++){
        if(i >= N) break;
        int num0 = 0, num1 = 0;
        int mid = R;
        for(int j = L; j < R; j++){
            if(S[j][i] == '0') num0++;
            else{
                mid = min(mid, j);
                num1++;
            }
        }

        if(num0 <= num1){
            t += '0';
            R = mid;
        }
        else{
            t += '1';
            L = mid;
        }
    }

    while(t.size() < size_t(N)) t += '*';
    cout << t << endl;
}
accuracy: 1
time_ms: 50
memory_kb: 13612
final_rank: 8

code_snippet: /* -*- coding: utf-8 -*-
 *
 * 3166.cc: Not Found
 */

#include<cstdio>
#include<algorithm>
 
using namespace std;

/* constant */

const int MAX_NM = 2500000;
const int MAX_L = 20;
const int LBITS = 1 << MAX_L;

/* typedef */

/* global variables */

char s[MAX_NM + 4];
bool used[LBITS];

/* subroutines */

/* main */

int main() {
  int n, m;
  scanf("%d%d", &n, &m);
  for (int i = 0; i < m; i++) scanf("%s", s + i * n);
  //puts(s);

  int l = min(n, MAX_L), lbits = 1 << l;

  for (int i = 0; i < m; i++) {
    char *t = s + i * n;
    int bits = 0;
    for (int j = 0; j < l; j++) bits = (bits << 1) | (t[j] - '0');
    used[bits] = true;
  }

  for (int bits = 0; bits < lbits; bits++)
    if (! used[bits]) {
      for (int i = 0; i < l; i++)
	putchar('0' + ((bits >> (l - 1 - i)) & 1));
      for (int i = l; i < n; i++) putchar('*');
      putchar('\n');
      break;
    }
  
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 5984
final_rank: 1

code_snippet: #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
using std::cout;
using std::cin;
using std::endl;
using ll=long long;
using ld=long double;
ll ILL=9167167167167167167;
const int INF=2100000000;
const ll mod=998244353;
#define rep(i,a) for (ll i=0;i<a;i++)
#define all(p) p.begin(),p.end()
template<class T> using _pq = priority_queue<T, vector<T>, greater<T>>;
template<class T> ll LB(vector<T> &v,T a){return lower_bound(v.begin(),v.end(),a)-v.begin();}
template<class T> ll UB(vector<T> &v,T a){return upper_bound(v.begin(),v.end(),a)-v.begin();}
template<class T> bool chmin(T &a,const T &b){if(a>b){a=b;return 1;}else return 0;}
template<class T> bool chmax(T &a,const T &b){if(a<b){a=b;return 1;}else return 0;}
template<class T> void So(vector<T> &v) {sort(v.begin(),v.end());}
template<class T> void Sore(vector<T> &v) {sort(v.begin(),v.end(),[](T x,T y){return x>y;});}
void yneos(bool a){if(a) cout<<"Yes\n"; else cout<<"No\n";}
template<class T> void vec_out(vector<T> &p){for(int i=0;i<(int)(p.size());i++){if(i) cout<<" ";cout<<p[i];}cout<<"\n";}


void solve();
// oddloop
int main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
	
	int t=1;
	//cin>>t;
	rep(i,t) solve();
}

void solve(){
	int n,m;
	cin>>n>>m;
	int x=0;
	while((1<<x)<=m) x++;
	assert(x<=20);
	vector<bool> p((1<<x));
	rep(i,m){
		string S;
		cin>>S;
		int tmp=0;
		rep(j,x){
			if(S[j]=='1') tmp+=(1<<j);
		}
		p[tmp]=1;
	}
	rep(i,(1<<x)){
		if(p[i]) continue;
		string ans;
		int D=i;
		rep(j,x) ans+=(char)(D%2+'0'),D/=2;
		rep(j,n-x) ans+='*';
		cout<<ans<<"\n";
		return;
	}
}
accuracy: 1
time_ms: 10
memory_kb: 10820
final_rank: 2

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main(){
    int n,m;
    cin >> n >> m;
    vector<string> s(m);
    for(int i=0; i<m; i++){
        cin >> s[i];
    }
    vector<bool> used(m, false);
    string ans = "";
    int rem = m;
    for(int i=0; i<n; i++){
        int count[2] = {};
        for(int j=0; j<m; j++){
            if(!used[j]) count[s[j][i]-'0']++;
        }
        char c = (count[0] < count[1])? '0': '1';
        ans += c;
        for(int j=0; j<m; j++){
            if(!used[j] and s[j][i] != c){
                used[j] = true;
                rem--;
            }
        }
        if(rem == 0){
            break;
        }
    }
    if(rem > 0){
        cout << "hokudai" << endl;
    }else{
        cout << ans << string(n-(int)ans.length(), '*') << endl;
    }
    return 0;
}
accuracy: 1
time_ms: 40
memory_kb: 11196
final_rank: 7

code_snippet: #line 2 "/home/yuruhiya/programming/library/template/template.cpp"
#include <bits/stdc++.h>
#line 4 "/home/yuruhiya/programming/library/template/constants.cpp"
#include <string_view>
#line 7 "/home/yuruhiya/programming/library/template/constants.cpp"

#define rep(i, n) for (int i = 0; i < (n); ++i)
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define rrep(i, n) for (int i = (n)-1; i >= 0; --i)
#define rfor(i, m, n) for (int i = (m); i >= (n); --i)
#define unless(c) if (!(c))
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define range_it(a, l, r) (a).begin() + (l), (a).begin() + (r)

using namespace std;
using ll = long long;
using LD = long double;
using VB = vector<bool>;
using VVB = vector<VB>;
using VI = vector<int>;
using VVI = vector<VI>;
using VL = vector<ll>;
using VVL = vector<VL>;
using VS = vector<string>;
using VD = vector<LD>;
using PII = pair<int, int>;
using VP = vector<PII>;
using PLL = pair<ll, ll>;
using VPL = vector<PLL>;
template <class T> using PQ = priority_queue<T>;
template <class T> using PQS = priority_queue<T, vector<T>, greater<T>>;
constexpr int inf = 1000000000;
constexpr long long inf_ll = 1000000000000000000ll, MOD = 1000000007;
constexpr long double PI = 3.14159265358979323846, EPS = 1e-12;
namespace CharacterClass {
	constexpr string_view
	    digit = "0123456789",
	    xdigit = "0123456789ABCDEFabcdef", lower = "abcdefghijklmnopqrstuvwxyz",
	    upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
	    alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
	    alnum = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
	    word = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz",
	    punct = R"(!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~)",
	    graph =
	        R"(!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~)",
	    print =
	        R"( !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~)",
	    blank = " \t", space = " \t\n\r\f\v";
}  // namespace CharacterClass
#line 7 "/home/yuruhiya/programming/library/template/Input.cpp"
using namespace std;

#ifdef _WIN32
#define getchar_unlocked _getchar_nolock
#define putchar_unlocked _putchar_nolock
#define fwrite_unlocked fwrite
#define fflush_unlocked fflush
#endif
class Scanner {
	static int gc() {
		return getchar_unlocked();
	}
	static char next_char() {
		char c;
		read(c);
		return c;
	}
	template <class T> static void read(T& v) {
		cin >> v;
	}
	static void read(char& v) {
		while (isspace(v = gc()))
			;
	}
	static void read(bool& v) {
		v = next_char() != '0';
	}
	static void read(string& v) {
		v.clear();
		for (char c = next_char(); !isspace(c); c = gc()) v += c;
	}
	static void read(int& v) {
		v = 0;
		bool neg = false;
		char c = next_char();
		if (c == '-') {
			neg = true;
			c = gc();
		}
		for (; isdigit(c); c = gc()) v = v * 10 + (c - '0');
		if (neg) v = -v;
	}
	static void read(long long& v) {
		v = 0;
		bool neg = false;
		char c = next_char();
		if (c == '-') {
			neg = true;
			c = gc();
		}
		for (; isdigit(c); c = gc()) v = v * 10 + (c - '0');
		if (neg) v = -v;
	}
	static void read(double& v) {
		v = 0;
		double dp = 1;
		bool neg = false, after_dp = false;
		char c = next_char();
		if (c == '-') {
			neg = true;
			c = gc();
		}
		for (; isdigit(c) || c == '.'; c = gc()) {
			if (c == '.') {
				after_dp = true;
			} else if (after_dp) {
				v += (c - '0') * (dp *= 0.1);
			} else {
				v = v * 10 + (c - '0');
			}
		}
		if (neg) v = -v;
	}
	static void read(long double& v) {
		v = 0;
		long double dp = 1;
		bool neg = false, after_dp = false;
		char c = next_char();
		if (c == '-') {
			neg = true;
			c = gc();
		}
		for (; isdigit(c) || c == '.'; c = gc()) {
			if (c == '.') {
				after_dp = true;
			} else if (after_dp) {
				v += (c - '0') * (dp *= 0.1);
			} else {
				v = v * 10 + (c - '0');
			}
		}
		if (neg) v = -v;
	}
	template <class T, class U> static void read(pair<T, U>& v) {
		read(v.first);
		read(v.second);
	}
	template <class T> static void read(vector<T>& v) {
		for (auto& e : v) read(e);
	}
	template <size_t N = 0, class T> static void read_tuple_impl(T& v) {
		if constexpr (N < tuple_size_v<T>) {
			read(get<N>(v));
			read_tuple_impl<N + 1>(v);
		}
	}
	template <class... T> static void read(tuple<T...>& v) {
		read_tuple_impl(v);
	}
	struct ReadVectorHelper {
		size_t n;
		ReadVectorHelper(size_t _n) : n(_n) {}
		template <class T> operator vector<T>() {
			vector<T> v(n);
			read(v);
			return v;
		}
	};
	struct Read2DVectorHelper {
		size_t n, m;
		Read2DVectorHelper(const pair<size_t, size_t>& nm) : n(nm.first), m(nm.second) {}
		template <class T> operator vector<vector<T>>() {
			vector<vector<T>> v(n, vector<T>(m));
			read(v);
			return v;
		}
	};

public:
	string read_line() const {
		string v;
		for (char c = gc(); c != '\n' && c != '\0'; c = gc()) v += c;
		return v;
	}
	template <class T> T read() const {
		T v;
		read(v);
		return v;
	}
	template <class T> vector<T> read_vector(size_t n) const {
		vector<T> a(n);
		read(a);
		return a;
	}
	template <class T> operator T() const {
		return read<T>();
	}
	int operator--(int) const {
		return read<int>() - 1;
	}
	ReadVectorHelper operator[](size_t n) const {
		return ReadVectorHelper(n);
	}
	Read2DVectorHelper operator[](const pair<size_t, size_t>& nm) const {
		return Read2DVectorHelper(nm);
	}
	void operator()() const {}
	template <class H, class... T> void operator()(H&& h, T&&... t) const {
		read(h);
		operator()(forward<T>(t)...);
	}

private:
	template <template <class...> class, class...> struct Multiple;
	template <template <class...> class V, class Head, class... Tail>
	struct Multiple<V, Head, Tail...> {
		template <class... Args> using vec = V<vector<Head>, Args...>;
		using type = typename Multiple<vec, Tail...>::type;
	};
	template <template <class...> class V> struct Multiple<V> { using type = V<>; };
	template <class... T> using multiple_t = typename Multiple<tuple, T...>::type;
	template <size_t N = 0, class T> void multiple_impl(T& t) const {
		if constexpr (N < tuple_size_v<T>) {
			auto& vec = get<N>(t);
			using V = typename remove_reference_t<decltype(vec)>::value_type;
			vec.push_back(read<V>());
			multiple_impl<N + 1>(t);
		}
	}

public:
	template <class... T> auto multiple(size_t h) const {
		multiple_t<T...> result;
		while (h--) multiple_impl(result);
		return result;
	}
} in;
#define inputs(T, ...) \
	T __VA_ARGS__;     \
	in(__VA_ARGS__)
#define ini(...) inputs(int, __VA_ARGS__)
#define inl(...) inputs(long long, __VA_ARGS__)
#define ins(...) inputs(string, __VA_ARGS__)
#line 7 "/home/yuruhiya/programming/library/template/Output.cpp"
#include <charconv>
#line 10 "/home/yuruhiya/programming/library/template/Output.cpp"
using namespace std;

struct BoolStr {
	const char *t, *f;
	BoolStr(const char* _t, const char* _f) : t(_t), f(_f) {}
} Yes("Yes", "No"), yes("yes", "no"), YES("YES", "NO"), Int("1", "0");
struct DivStr {
	const char *d, *l;
	DivStr(const char* _d, const char* _l) : d(_d), l(_l) {}
} spc(" ", "\n"), no_spc("", "\n"), end_line("\n", "\n"), comma(",", "\n"),
    no_endl(" ", "");
class Output {
	BoolStr B{Yes};
	DivStr D{spc};

public:
	void put(int v) const {
		char buf[12]{};
		if (auto [ptr, e] = to_chars(begin(buf), end(buf), v); e == errc{}) {
			fwrite(buf, sizeof(char), ptr - buf, stdout);
		} else {
			assert(false);
		}
	}
	void put(long long v) const {
		char buf[21]{};
		if (auto [ptr, e] = to_chars(begin(buf), end(buf), v); e == errc{}) {
			fwrite(buf, sizeof(char), ptr - buf, stdout);
		} else {
			assert(false);
		}
	}
	void put(bool v) const {
		put(v ? B.t : B.f);
	}
	void put(vector<bool>::reference v) const {
		put(v ? B.t : B.f);
	}
	void put(char v) const {
		putchar_unlocked(v);
	}
	void put(const char* v) const {
		fwrite_unlocked(v, 1, strlen(v), stdout);
	}
	void put(double v) const {
		printf("%.20f", v);
	}
	void put(long double v) const {
		printf("%.20Lf", v);
	}
	template <class T> void put(const T& v) const {
		cout << v;
	}
	template <class T, class U> void put(const pair<T, U>& v) const {
		put(v.first);
		put(D.d);
		put(v.second);
	}
	template <class InputIterater>
	void put_range(const InputIterater& begin, const InputIterater& end) const {
		for (InputIterater i = begin; i != end; ++i) {
			if (i != begin) put(D.d);
			put(*i);
		}
	}
	template <class T> void put(const vector<T>& v) const {
		put_range(v.begin(), v.end());
	}
	template <class T, size_t N> void put(const array<T, N>& v) const {
		put_range(v.begin(), v.end());
	}
	template <class T> void put(const vector<vector<T>>& v) const {
		for (size_t i = 0; i < v.size(); ++i) {
			if (i) put(D.l);
			put(v[i]);
		}
	}

	Output() = default;
	Output(const BoolStr& _boolstr, const DivStr& _divstr) : B(_boolstr), D(_divstr) {}
	Output& operator()() {
		put(D.l);
		return *this;
	}
	template <class H> Output& operator()(H&& h) {
		put(h);
		put(D.l);
		return *this;
	}
	template <class H, class... T> Output& operator()(H&& h, T&&... t) {
		put(h);
		put(D.d);
		return operator()(forward<T>(t)...);
	}
	template <class InputIterator>
	Output& range(const InputIterator& begin, const InputIterator& end) {
		put_range(begin, end);
		put(D.l);
		return *this;
	}
	template <class T> Output& range(const T& a) {
		range(a.begin(), a.end());
		return *this;
	}
	template <class... T> void exit(T&&... t) {
		operator()(forward<T>(t)...);
		std::exit(EXIT_SUCCESS);
	}
	Output& flush() {
		fflush_unlocked(stdout);
		return *this;
	}
	Output& set(const BoolStr& b) {
		B = b;
		return *this;
	}
	Output& set(const DivStr& d) {
		D = d;
		return *this;
	}
	Output& set(const char* t, const char* f) {
		B = BoolStr(t, f);
		return *this;
	}
} out;
#line 3 "/home/yuruhiya/programming/library/template/Step.cpp"
using namespace std;

template <class T> struct Step {
	using value_type = T;

	class iterator {
		value_type a, b, c;

	public:
		constexpr iterator() : a(value_type()), b(value_type()), c(value_type()) {}
		constexpr iterator(value_type _b, value_type _c, value_type _s)
		    : a(_b), b(_c), c(_s) {}
		constexpr iterator& operator++() {
			--b;
			a += c;
			return *this;
		}
		constexpr iterator operator++(int) {
			iterator tmp = *this;
			--b;
			a += c;
			return tmp;
		}
		constexpr const value_type& operator*() const {
			return a;
		}
		constexpr const value_type* operator->() const {
			return &a;
		}
		constexpr bool operator==(const iterator& i) const {
			return b == i.b;
		}
		constexpr bool operator!=(const iterator& i) const {
			return !(b == i.b);
		}
		constexpr value_type start() const {
			return a;
		}
		constexpr value_type size() const {
			return b;
		}
		constexpr value_type step() const {
			return c;
		}
	};
	constexpr Step(value_type b, value_type c, value_type s) : be(b, c, s) {}
	constexpr iterator begin() const {
		return be;
	}
	constexpr iterator end() const {
		return en;
	}
	constexpr value_type start() const {
		return be.start();
	}
	constexpr value_type size() const {
		return be.size();
	}
	constexpr value_type step() const {
		return be.step();
	}
	constexpr value_type sum() const {
		return start() * size() + step() * (size() * (size() - 1) / 2);
	}
	operator vector<value_type>() const {
		return to_a();
	}
	auto to_a() const {
		vector<value_type> result;
		result.reserve(size());
		for (auto i : *this) {
			result.push_back(i);
		}
		return result;
	}

private:
	iterator be, en;
};
template <class T> constexpr auto step(T a) {
	return Step<T>(0, a, 1);
}
template <class T> constexpr auto step(T a, T b) {
	return Step<T>(a, b - a, 1);
}
template <class T> constexpr auto step(T a, T b, T c) {
	return Step<T>(a, a < b ? (b - a - 1) / c + 1 : 0, c);
}
#line 8 "/home/yuruhiya/programming/library/template/Ruby.cpp"
using namespace std;

template <class F> struct Callable {
	F func;
	Callable(const F& f) : func(f) {}
};
template <class T, class F> auto operator|(const T& v, const Callable<F>& c) {
	return c.func(v);
}

struct Sort_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			sort(begin(v), end(v), f);
			return v;
		});
	}
	template <class T> friend auto operator|(T v, [[maybe_unused]] const Sort_impl& c) {
		sort(begin(v), end(v));
		return v;
	}
} Sort;
struct SortBy_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			sort(begin(v), end(v),
			     [&](const auto& i, const auto& j) { return f(i) < f(j); });
			return v;
		});
	}
} SortBy;
struct RSort_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			sort(rbegin(v), rend(v), f);
			return v;
		});
	}
	template <class T> friend auto operator|(T v, [[maybe_unused]] const RSort_impl& c) {
		sort(rbegin(v), rend(v));
		return v;
	}
} RSort;
struct RSortBy_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			sort(begin(v), end(v),
			     [&](const auto& i, const auto& j) { return f(i) > f(j); });
			return v;
		});
	}
} RSortBy;
struct Reverse_impl {
	template <class T> friend auto operator|(T v, const Reverse_impl& c) {
		reverse(begin(v), end(v));
		return v;
	}
} Reverse;
struct Unique_impl {
	template <class T> friend auto operator|(T v, const Unique_impl& c) {
		v.erase(unique(begin(v), end(v), end(v)));
		return v;
	}
} Unique;
struct Uniq_impl {
	template <class T> friend auto operator|(T v, const Uniq_impl& c) {
		sort(begin(v), end(v));
		v.erase(unique(begin(v), end(v)), end(v));
		return v;
	}
} Uniq;
struct Rotate_impl {
	auto operator()(int&& left) {
		return Callable([&](auto v) {
			int s = static_cast<int>(size(v));
			assert(-s <= left && left <= s);
			if (0 <= left) {
				rotate(begin(v), begin(v) + left, end(v));
			} else {
				rotate(begin(v), end(v) + left, end(v));
			}
			return v;
		});
	}
} Rotate;
struct Max_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) { return *max_element(begin(v), end(v), f); });
	}
	template <class T> friend auto operator|(T v, const Max_impl& c) {
		return *max_element(begin(v), end(v));
	}
} Max;
struct Min_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) { return *min_element(begin(v), end(v), f); });
	}
	template <class T> friend auto operator|(T v, const Min_impl& c) {
		return *min_element(begin(v), end(v));
	}
} Min;
struct MaxPos_impl {
	template <class T> friend auto operator|(T v, const MaxPos_impl& c) {
		return max_element(begin(v), end(v)) - begin(v);
	}
} MaxPos;
struct MinPos_impl {
	template <class T> friend auto operator|(T v, const MinPos_impl& c) {
		return min_element(begin(v), end(v)) - begin(v);
	}
} MinPos;
struct MaxBy_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			auto max_it = begin(v);
			auto max_val = f(*max_it);
			for (auto it = next(begin(v)); it != end(v); ++it) {
				if (auto val = f(*it); max_val < val) {
					max_it = it;
					max_val = val;
				}
			}
			return *max_it;
		});
	}
} MaxBy;
struct MinBy_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			auto min_it = begin(v);
			auto min_val = f(*min_it);
			for (auto it = next(begin(v)); it != end(v); ++it) {
				if (auto val = f(*it); min_val > val) {
					min_it = it;
					min_val = val;
				}
			}
			return *min_it;
		});
	}
} MinBy;
struct MaxOf_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			auto max_val = f(*begin(v));
			for (auto it = next(begin(v)); it != end(v); ++it) {
				if (auto val = f(*it); max_val < val) {
					max_val = val;
				}
			}
			return max_val;
		});
	}
} MaxOf;
struct MinOf_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			auto min_val = f(*begin(v));
			for (auto it = next(begin(v)); it != end(v); ++it) {
				if (auto val = f(*it); min_val > val) {
					min_val = val;
				}
			}
			return min_val;
		});
	}
} MinOf;
struct Count_impl {
	template <class V> auto operator()(const V& val) {
		return Callable([&](auto v) { return count(begin(v), end(v), val); });
	}
} Count;
struct CountIf_impl {
	template <class F> auto operator()(const F& f) {
		return Callable([&](auto v) { return count_if(begin(v), end(v), f); });
	}
} CountIf;
struct Index_impl {
	template <class V> auto operator()(const V& val) {
		return Callable([&](auto v) -> optional<int> {
			auto result = find(begin(v), end(v), val);
			return result != end(v) ? optional(result - begin(v)) : nullopt;
		});
	}
} Index;
struct IndexIf_impl {
	template <class F> auto operator()(const F& f) {
		return Callable([&](auto v) -> optional<int> {
			auto result = find_if(begin(v), end(v), f);
			return result != end(v) ? optional(result - begin(v)) : nullopt;
		});
	}
} IndexIf;
struct FindIf_impl {
	template <class F> auto operator()(const F& f) {
		return Callable([&](auto v) -> optional<typename decltype(v)::value_type> {
			auto result = find_if(begin(v), end(v), f);
			return result != end(v) ? optional(*result) : nullopt;
		});
	}
} FindIf;
struct Sum_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			return accumulate(next(begin(v)), end(v), f(*begin(v)),
			                  [&](const auto& a, const auto& b) { return a + f(b); });
		});
	}
	template <class T> friend auto operator|(T v, const Sum_impl& c) {
		return accumulate(begin(v), end(v), typename T::value_type{});
	}
} Sum;
struct Includes {
	template <class V> auto operator()(const V& val) {
		return Callable([&](auto v) { return find(begin(v), end(v), val) != end(v); });
	}
} Includes;
struct IncludesIf_impl {
	template <class F> auto operator()(const F& f) {
		return Callable([&](auto v) { return find_if(begin(v), end(v), f) != end(v); });
	}
} IncludesIf;
struct RemoveIf_impl {
	template <class F> auto operator()(const F& f) {
		return Callable([&](auto v) {
			v.erase(remove_if(begin(v), end(v), f), end(v));
			return v;
		});
	}
} RemoveIf;
struct Each_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			for (const auto& i : v) {
				f(i);
			}
		});
	}
} Each;
struct Select_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			using value_type = typename decltype(v)::value_type;
			vector<value_type> result;
			for (const auto& i : v) {
				if (f(i)) result.push_back(i);
			}
			return result;
		});
	}
} Select;
struct Map_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			using result_type = invoke_result_t<F, typename decltype(v)::value_type>;
			vector<result_type> result;
			result.reserve(size(v));
			for (const auto& i : v) {
				result.push_back(f(i));
			}
			return result;
		});
	}
} Map;
struct Indexed_impl {
	template <class T> friend auto operator|(const T& v, Indexed_impl& c) {
		using value_type = typename T::value_type;
		vector<pair<value_type, int>> result;
		result.reserve(size(v));
		int index = 0;
		for (const auto& i : v) {
			result.emplace_back(i, index++);
		}
		return result;
	}
} Indexed;
struct AllOf_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			for (const auto& i : v) {
				if (!f(i)) return false;
			}
			return true;
		});
	}
} AllOf;
struct AnyOf_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			for (const auto& i : v) {
				if (f(i)) return true;
			}
			return false;
		});
	}
} AnyOf;
struct NoneOf_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			for (const auto& i : v) {
				if (f(i)) return false;
			}
			return true;
		});
	}
} NoneOf;

struct Tally_impl {
	template <class F> auto operator()(size_t max_val) {
		return Callable([&](auto v) {
			vector<size_t> result(max_val);
			for (const auto& i : v) {
				result[static_cast<size_t>(i)]++;
			}
			return result;
		});
	}
	template <class T, class value_type = typename T::value_type>
	friend auto operator|(const T& v, Tally_impl& c) {
		map<value_type, size_t> result;
		for (const auto& i : v) {
			result[i]++;
		}
		return result;
	}
} Tally;

template <class T> auto operator*(const vector<T>& a, size_t n) {
	T result;
	for (size_t i = 0; i < n; ++i) {
		result.insert(result.end(), a.begin(), a.end());
	}
	return result;
}
auto operator*(string a, size_t n) {
	string result;
	for (size_t i = 0; i < n; ++i) {
		result += a;
	}
	return result;
}
template <class T, class U> auto& operator<<(vector<T>& a, const U& b) {
	a.insert(a.end(), all(b));
	return a;
}
template <class T> auto& operator<<(string& a, const T& b) {
	a.insert(a.end(), all(b));
	return a;
}
template <class T, class U> auto operator+(vector<T> a, const U& b) {
	a << b;
	return a;
}
template <class T> auto operator+(string a, const T& b) {
	a << b;
	return a;
}
#line 7 "/home/yuruhiya/programming/library/template/functions.cpp"
using namespace std;

template <class T = long long> constexpr T TEN(size_t n) {
	T result = 1;
	for (size_t i = 0; i < n; ++i) result *= 10;
	return result;
}
template <class T, class U,
          enable_if_t<is_integral_v<T> && is_integral_v<U>, nullptr_t> = nullptr>
constexpr auto div_ceil(T n, U m) {
	return (n + m - 1) / m;
}
template <class T, class U> constexpr auto div_ceil2(T n, U m) {
	return div_ceil(n, m) * m;
}
template <class T> constexpr T triangle(T n) {
	return (n & 1) ? (n + 1) / 2 * n : n / 2 * (n + 1);
}
template <class T> constexpr T nC2(T n) {
	return (n & 1) ? (n - 1) / 2 * n : n / 2 * (n - 1);
}
template <class T, class U> constexpr auto middle(const T& l, const U& r) {
	return l + (r - l) / 2;
}
template <class T, class U, class V>
constexpr bool in_range(const T& v, const U& lower, const V& upper) {
	return lower <= v && v < upper;
}
template <class T, enable_if_t<is_integral_v<T>, nullptr_t> = nullptr>
constexpr bool is_square(T n) {
	T s = sqrt(n);
	return s * s == n || (s + 1) * (s + 1) == n;
}
template <class T = long long> constexpr T BIT(int b) {
	return T(1) << b;
}
template <class T> constexpr int BIT(T x, int i) {
	return (x & (1 << i)) ? 1 : 0;
}
template <class T, class U, enable_if_t<is_integral_v<U>, nullptr_t> = nullptr>
constexpr T Pow(T a, U n) {
	assert(n >= 0);
	T result = 1;
	while (n > 0) {
		if (n & 1) {
			result *= a;
			n--;
		} else {
			a *= a;
			n >>= 1;
		}
	}
	return result;
}
template <class T, class U, enable_if_t<is_integral_v<U>, nullptr_t> = nullptr>
constexpr T Powmod(T a, U n, T mod) {
	assert(n >= 0);
	if (a > mod) a %= mod;
	T result = 1;
	while (n > 0) {
		if (n & 1) {
			result = result * a % mod;
			n--;
		} else {
			a = a * a % mod;
			n >>= 1;
		}
	}
	return result;
}
template <class T> bool chmax(T& a, const T& b) {
	if (a < b) {
		a = b;
		return true;
	}
	return false;
}
template <class T> bool chmin(T& a, const T& b) {
	if (a > b) {
		a = b;
		return true;
	}
	return false;
}
template <class T> int sz(const T& v) {
	return v.size();
}
template <class T, class U> int lower_index(const T& a, const U& v) {
	return lower_bound(all(a), v) - a.begin();
}
template <class T, class U> int upper_index(const T& a, const U& v) {
	return upper_bound(all(a), v) - a.begin();
}
template <class T> auto Slice(const T& v, size_t i, size_t len) {
	return i < v.size() ? T(v.begin() + i, v.begin() + min(i + len, v.size())) : T();
}
template <class T, class U = typename T::value_type> U Gcdv(const T& v) {
	return accumulate(next(v.begin()), v.end(), U(*v.begin()), gcd<U, U>);
}
template <class T, class U = typename T::value_type> U Lcmv(const T& v) {
	return accumulate(next(v.begin()), v.end(), U(*v.begin()), lcm<U, U>);
}
namespace internal {
	template <class T, size_t N> auto make_vector(vector<int>& sizes, const T& init) {
		if constexpr (N == 1) {
			return vector(sizes[0], init);
		} else {
			int size = sizes[N - 1];
			sizes.pop_back();
			return vector(size, make_vector<T, N - 1>(sizes, init));
		}
	}
}  // namespace internal
template <class T, size_t N>
auto make_vector(const int (&sizes)[N], const T& init = T()) {
	vector s(rbegin(sizes), rend(sizes));
	return internal::make_vector<T, N>(s, init);
}
#line 9 "/home/yuruhiya/programming/library/template/template.cpp"
#if __has_include(<library/dump.hpp>)
#include <library/dump.hpp>
#define LOCAL
#else
#define dump(...) ((void)0)
#endif

template <class T> constexpr T oj_local(const T& oj, const T& local) {
#ifndef LOCAL
	return oj;
#else
	return local;
#endif
}
#line 2 "a.cpp"

int main() {
	ini(n, m);
	VS s = in[m];

	int len = min(20, n);
	VB flag(1 << len);
	rep(i, m) {
		int val = stoi(s[i].substr(0, len), nullptr, 2);
		flag[val] = true;
	}
	rep(i, 1 << len) {
		if (!flag[i]) {
			string ans;
			rep(d, len) ans += BIT(i, len - 1 - d) + '0';
			ans += string(n - len, '*');
			out.exit(ans);
		}
	}
}
accuracy: 1
time_ms: 10
memory_kb: 11484
final_rank: 3

code_snippet: #define MOD_TYPE 2

#pragma region Macros

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

#if 0
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
using Int = boost::multiprecision::cpp_int;
using lld = boost::multiprecision::cpp_dec_float_100;
#endif
#if 0
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#endif
using ll = long long int;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pld = pair<ld, ld>;
template <typename Q_type>
using smaller_queue = priority_queue<Q_type, vector<Q_type>, greater<Q_type>>;

constexpr ll MOD = (MOD_TYPE == 1 ? (ll)(1e9 + 7) : 998244353);
constexpr int INF = (int)1e9 + 10;
constexpr ll LINF = (ll)4e18;
constexpr double PI = acos(-1.0);
constexpr double EPS = 1e-7;
constexpr int Dx[] = {0, 0, -1, 1, -1, 1, -1, 1, 0};
constexpr int Dy[] = {1, -1, 0, 0, -1, -1, 1, 1, 0};

#define REP(i, m, n) for (ll i = m; i < (ll)(n); ++i)
#define rep(i, n) REP(i, 0, n)
#define REPI(i, m, n) for (int i = m; i < (int)(n); ++i)
#define repi(i, n) REPI(i, 0, n)
#define MP make_pair
#define MT make_tuple
#define YES(n) cout << ((n) ? "YES" : "NO") << "\n"
#define Yes(n) cout << ((n) ? "Yes" : "No") << "\n"
#define possible(n) cout << ((n) ? "possible" : "impossible") << "\n"
#define Possible(n) cout << ((n) ? "Possible" : "Impossible") << "\n"
#define all(v) v.begin(), v.end()
#define NP(v) next_permutation(all(v))
#define dbg(x) cerr << #x << ":" << x << "\n";

struct io_init
{
  io_init()
  {
    cin.tie(0);
    ios::sync_with_stdio(false);
    cout << setprecision(30) << setiosflags(ios::fixed);
  };
} io_init;
template <typename T>
inline bool chmin(T &a, T b)
{
  if (a > b)
  {
    a = b;
    return true;
  }
  return false;
}
template <typename T>
inline bool chmax(T &a, T b)
{
  if (a < b)
  {
    a = b;
    return true;
  }
  return false;
}
inline ll CEIL(ll a, ll b)
{
  return (a + b - 1) / b;
}
template <typename A, size_t N, typename T>
inline void Fill(A (&array)[N], const T &val)
{
  fill((T *)array, (T *)(array + N), val);
}
template <typename T, typename U>
constexpr istream &operator>>(istream &is, pair<T, U> &p) noexcept
{
  is >> p.first >> p.second;
  return is;
}
template <typename T, typename U>
constexpr ostream &operator<<(ostream &os, pair<T, U> &p) noexcept
{
  os << p.first << " " << p.second;
  return os;
}
#pragma endregion

void solve()
{
  int n, m;
  cin >> n >> m;
  assert(m < (1 << 20));
  if (m >= (1 << 20))
  {
    cout << "hokudai\n";
    return;
  }
  vector<string> s(m);
  rep(i, m) cin >> s[i];
  string t;
  vector<int> idx(m);
  iota(all(idx), 0);
  rep(j, min(20, n))
  {
    vector<int> v[2];
    for (auto i : idx)
    {
      v[s[i][j] == '1'].push_back(i);
    }
    if (v[0].size() <= v[1].size())
    {
      t.push_back('0');
      idx = move(v[0]);
    }
    else
    {
      t.push_back('1');
      idx = move(v[1]);
    }
  }
  while (t.length() < n)
    t.push_back('*');
  assert(t.length() == n);
  cout << t << "\n";
}

int main()
{
  solve();
}
accuracy: 1
time_ms: 10
memory_kb: 12336
final_rank: 4

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

int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};

int main() {
  int n, m;
  cin >> n >> m;
  vector<string> s(m);
  for (int i = 0; i < m; i++) cin >> s[i];

  string ans = "";
  vector<int> flag(m, true);
  for (int i = 0; i < n; i++) {
    if (i >= 20) {
      ans += "*";
      continue;
    }
    int cnt0 = 0;
    int rest = 0;
    for (int j = 0; j < m; j++) {
      if (!flag[j]) continue;
      rest++;
      if (s[j][i] == '0') cnt0++;
    }
    int cnt1 = rest - cnt0;
    if (cnt0 < cnt1)
      ans += "0";
    else
      ans += "1";

    vector<string> news;
    for (int j = 0; j < m; j++) {
      if (!flag[j]) continue;
      if (cnt0 < cnt1 && s[j][i] == '1' || cnt0 >= cnt1 && s[j][i] == '0') {
        flag[j] = false;
      }
    }
  }

  cout << ans << endl;

  return 0;
}
accuracy: 1
time_ms: 80
memory_kb: 12200
final_rank: 9

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

int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};

int main() {
  int n, m;
  cin >> n >> m;
  vector<string> s(m);
  for(int i=0;i<m;i++) cin>>s[i];

  string ans = "";
  vector<int> flag(m,true);
  for(int i=0;i<n;i++){
    if(i>=20) {
      ans+="*";
      continue;
    }
    int cnt0 = 0;
    int rest = 0;
    for(int j=0;j<m;j++){
      if(!flag[j]) continue;
      rest++;
      if(s[j][i] == '0') cnt0++;
    }
    int cnt1 = rest - cnt0;
    if(cnt0<cnt1) ans+="0";
    else ans+="1";
    
    vector<string> news;
    for(int j=0;j<m;j++){
      if(!flag[j]) continue;
      if(cnt0<cnt1 && s[j][i]=='0' || cnt0>=cnt1 && s[j][i]=='1') {
        flag[j] = false;
      }
    }
  }

  cout<<ans<<endl;

  return 0;
}
accuracy: 0.14634146341463414
time_ms: 60
memory_kb: 11456
final_rank: 17

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

int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};

int main() {
  int n, m;
  cin >> n >> m;
  vector<string> s(m);
  for(int i=0;i<m;i++) cin>>s[i];

  string ans = "";
  vector<int> flag(n,true);
  for(int i=0;i<n;i++){
    if(i>=20) {
      ans+="*";
      continue;
    }
    int cnt0 = 0;
    int rest = 0;
    for(int j=0;j<m;j++){
      if(!flag[i]) continue;
      rest++;
      if(s[j][i] == '0') cnt0++;
    }
    int cnt1 = rest - cnt0;
    if(cnt0<cnt1) ans+="0";
    else ans+="1";
    
    vector<string> news;
    for(int j=0;j<m;j++){
      if(!flag[j]) continue;
      if(cnt0<cnt1 && s[j][i]=='0' || cnt0>=cnt1 && s[j][i]=='1') {
        flag[j] = false;
      }
    }
  }

  cout<<ans<<endl;

  return 0;
}
accuracy: 0.14634146341463414
time_ms: 60
memory_kb: 21056
final_rank: 18

code_snippet: #include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 9223372036854775807
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;


#define SIZE 2500005
#define MAX 22

int N,M;
int POW[MAX+1];
bool check[SIZE][2],used[1<<22];
string line[SIZE];

int main(){

	POW[0] = 1;
	for(int i = 1; i <= MAX; i++){

		POW[i] = POW[i-1]*2;
	}

	scanf("%d %d",&N,&M);

	for(int i = 0; i < N; i++){
		for(int k = 0; k < 2; k++){
			check[i][k] = false;
		}
	}

	for(int i = 0; i < M; i++){

		cin >> line[i];
		for(int k = 0; k < line[i].length(); k++){
			check[k][line[i][k]-'0'] = true;
		}
	}

	for(int i = 0; i < N; i++){
		for(int k = 0; k < 2; k++){
			if(!check[i][k]){
				for(int a = 0; a < i; a++){
					printf("*");
				}
				printf("%d",k);
				for(int a = i+1; a < N; a++){
					printf("*");
				}
				printf("\n");
				return 0;
			}
		}
	}

	for(int i = 0; i < POW[min(MAX,N)]; i++){

		used[i] = false;
	}

	for(int i = 0; i < M; i++){

		int tmp = 0;
		for(int k = 0; k < min(MAX,N); k++){

			tmp = 2*tmp+(line[i][k]-'0');
		}
		used[tmp] = true;
	}

	for(int i = 0; i < POW[min(MAX,N)]; i++){
		if(!used[i]){

			int tmp = i;
			for(int k = min(MAX,N)-1; k >= 0; k--){
				if(POW[k] <= tmp){
					tmp -= POW[k];
					printf("1");

				}else{

					printf("0");
				}
			}
			if(MAX < N){
				int diff = N-MAX;
				for(int a = 0; a < diff; a++){
					printf("*");
				}
			}
			printf("\n");
			return 0;
		}
	}

	printf("hokudai\n");

	return 0;
}
accuracy: 0.24390243902439024
time_ms: 60
memory_kb: 31312
final_rank: 14

code_snippet: #include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 9223372036854775807
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;


#define SIZE 2500005
#define MAX 27

int N,M;
int POW[MAX+1];
bool check[SIZE][2],used[1<<27];
string line[SIZE];

int main(){

	POW[0] = 1;
	for(int i = 1; i <= MAX; i++){

		POW[i] = POW[i-1]*2;
	}

	scanf("%d %d",&N,&M);

	for(int i = 0; i < N; i++){
		for(int k = 0; k < 2; k++){
			check[i][k] = false;
		}
	}

	for(int i = 0; i < M; i++){

		cin >> line[i];
		for(int k = 0; k < line[i].length(); k++){
			check[k][line[i][k]-'0'] = true;
		}
	}

	for(int i = 0; i < N; i++){
		for(int k = 0; k < 2; k++){
			if(!check[i][k]){
				for(int a = 0; a < i; a++){
					printf("*");
				}
				printf("%d",k);
				for(int a = i+1; a < N; a++){
					printf("*");
				}
				printf("\n");
				return 0;
			}
		}
	}

	for(int i = 0; i < POW[N]; i++){

		used[i] = false;
	}

	for(int i = 0; i < M; i++){

		int tmp = 0;
		for(int k = 0; k < N; k++){

			tmp = 2*tmp+(line[i][k]-'0');
		}
		used[tmp] = true;
	}

	for(int i = 0; i < POW[N]; i++){
		if(!used[i]){

			int tmp = i;
			for(int k = N-1; k >= 0; k--){
				if(POW[k] <= tmp){
					tmp -= POW[k];
					printf("1");

				}else{

					printf("0");
				}
			}
			printf("\n");
			return 0;
		}
	}

	printf("hokudai\n");

	return 0;
}
accuracy: 0.24390243902439024
time_ms: 60
memory_kb: 57668
final_rank: 15

code_snippet: #include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 9223372036854775807
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;


#define SIZE 2500005
#define MAX 22

int N,M;
int POW[MAX+1];
bool check[SIZE][2],used[1<<22];
string line[SIZE];

int main(){

	POW[0] = 1;
	for(int i = 1; i <= MAX; i++){

		POW[i] = POW[i-1]*2;
	}

	scanf("%d %d",&N,&M);

	for(int i = 0; i < N; i++){
		for(int k = 0; k < 2; k++){
			check[i][k] = false;
		}
	}

	for(int i = 0; i < M; i++){

		cin >> line[i];
		for(int k = 0; k < line[i].length(); k++){
			check[k][line[i][k]-'0'] = true;
		}
	}

	for(int i = 0; i < N; i++){
		for(int k = 0; k < 2; k++){
			if(!check[i][k]){
				for(int a = 0; a < i; a++){
					printf("*");
				}
				printf("%d",k);
				for(int a = i+1; a < N; a++){
					printf("*");
				}
				printf("\n");
				return 0;
			}
		}
	}

	for(int i = 0; i < POW[N]; i++){

		used[i] = false;
	}

	for(int i = 0; i < M; i++){

		int tmp = 0;
		for(int k = 0; k < N; k++){

			tmp = 2*tmp+(line[i][k]-'0');
		}
		used[tmp] = true;
	}

	for(int i = 0; i < POW[N]; i++){
		if(!used[i]){

			int tmp = i;
			for(int k = N-1; k >= 0; k--){
				if(POW[k] <= tmp){
					tmp -= POW[k];
					printf("1");

				}else{

					printf("0");
				}
			}
			printf("\n");
			return 0;
		}
	}

	printf("hokudai\n");

	return 0;
}
accuracy: 0.24390243902439024
time_ms: 60
memory_kb: 31308
final_rank: 13

code_snippet: #ifdef ONLINE_JUDGE
#pragma GCC target("avx2,avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#endif
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using i128 = __int128_t;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
#define rep(i, n) for(int i = 0; i < (n); ++i)
#define all(x) (x).begin(),(x).end()
constexpr char ln = '\n';
istream& operator>>(istream& is, __int128_t &x) {
    x = 0;
    string s;
    is >> s;
    int n = int(s.size()), it = 0;
    if (s[0] == '-') it++;
    for (; it < n; it++) x = (x * 10 + s[it] - '0');
    if (s[0] == '-') x = -x;
    return is;
}
ostream& operator<<(ostream& os, __int128_t x) {
    if (x == 0) return os << 0;
    if (x < 0) os << '-', x = -x;
    deque<int> deq;
    while (x) deq.emplace_front(x % 10), x /= 10;
    for (int e : deq) os << e;
    return os;
}
template<class T1, class T2>
ostream& operator<<(ostream& os, const pair<T1, T2>& p) {
    return os << "(" << p.first << ", " << p.second << ")";
}
template<class T> 
ostream& operator<<(ostream& os, const vector<T>& v) {
    os << "[";
    for(auto e : v) os << e << ", ";
    return os << "]";
}
template<class Container> inline int SZ(Container& v) {return int(v.size());}
template<class T1, class T2> inline bool chmax(T1 &a, T2 b) {if (a < b) {a = b; return true;} return false;}
template<class T1, class T2> inline bool chmin(T1 &a, T2 b) {if (a > b) {a = b; return true;} return false;}
inline int topbit(int x) {return x == 0 ? -1 : 31 - __builtin_clz(x);}
inline int topbit(long long x) {return x == 0 ? -1 : 63 - __builtin_clzll(x);}
inline int botbit(int x) {return x == 0 ? 32 : __builtin_ctz(x);}
inline int botbit(long long x) {return x == 0 ? 64 : __builtin_ctzll(x);}
inline int popcount(int x) {return __builtin_popcount(x);}
inline int popcount(long long x) {return __builtin_popcountll(x);}
inline int kthbit(long long x, int k) {return (x>>k)&1;}
inline constexpr long long TEN(int x) {return x == 0 ? 1 : TEN(x-1) * 10;}
namespace detail {
    template<typename Tp, int Nb>
    auto make_vector(vector<int>& sizes, Tp const& x) {
        if constexpr (Nb == 1) {
            return vector(sizes[0], x);
        } else {
            int size = sizes[Nb-1];
            sizes.pop_back();
            return vector(size, make_vector<Tp, Nb-1>(sizes, x));
        }
    }
}
template<typename Tp, int Nb>
auto make_vector(int const(&sizes)[Nb], Tp const& x = Tp()) {
    vector<int> s(Nb);
    for (int i = 0; i < Nb; i++) s[i] = sizes[Nb-i-1];
    return detail::make_vector<Tp, Nb>(s, x);
}
inline void print() {cout << "\n";}
template<class T>
inline void print(const vector<T>& v) {
    for (auto itr = v.begin(); itr != v.end(); ++itr) cout << *itr << " ";
    print();
}
template<class T, class... Args>
inline void print(const T &x, const Args &... args) {
    cout << x << " ";
    print(args...);
}
#ifdef MINATO_LOCAL
#define dump(x) cerr << __LINE__ << " : " << #x << " = " << (x) << endl;
inline void debug() {cerr << endl;}
template<class T>
inline void debug(const vector<T> &v) {
    for (auto itr = v.begin(); itr != v.end(); ++itr) cerr << *itr << " ";
    debug();
}
template<class T, class... Args>
inline void debug(const T &x, const Args &... args) {
    cerr << x << " ";
    debug(args...);
}
#else
#define dump(x) void(0)
inline void debug() {}
template<class T> inline void debug(const vector<T> &v) {}
template<class T, class... Args> inline void debug(const T &x, const Args &... args) {}
#endif
struct Fast_ios {Fast_ios() {cin.tie(nullptr); ios::sync_with_stdio(false); cout << fixed << setprecision(20);};} fast_ios;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

int main() {
    int N,M; cin >> N >> M;
    vector<string> S(M);
    rep(i,M) cin >> S[i];

    int K = min(N,20);
    vector<bool> seen(1<<K);
    rep(i,M) {
        int a = 0;
        rep(j,K) {
            if (S[i][j]=='1') a |= (1<<j);
        }
        seen[a] = 1;
    }

    rep(i,1<<K) {
        if (!seen[i]) {
            string ans = "";
            rep(bit,K) {
                if (kthbit(i,bit)) ans += '1';
                else ans += '0';
            }
            while (int(ans.size()) < N) ans += '*';
            cout << ans << ln;
            return 0;
        }
    }

    cout << "hokudai" << ln;
}
accuracy: 1
time_ms: 10
memory_kb: 13764
final_rank: 5

code_snippet: #ifdef ONLINE_JUDGE
#pragma GCC target("avx2,avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#endif
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using i128 = __int128_t;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
#define rep(i, n) for(int i = 0; i < (n); ++i)
#define all(x) (x).begin(),(x).end()
constexpr char ln = '\n';
istream& operator>>(istream& is, __int128_t &x) {
    x = 0;
    string s;
    is >> s;
    int n = int(s.size()), it = 0;
    if (s[0] == '-') it++;
    for (; it < n; it++) x = (x * 10 + s[it] - '0');
    if (s[0] == '-') x = -x;
    return is;
}
ostream& operator<<(ostream& os, __int128_t x) {
    if (x == 0) return os << 0;
    if (x < 0) os << '-', x = -x;
    deque<int> deq;
    while (x) deq.emplace_front(x % 10), x /= 10;
    for (int e : deq) os << e;
    return os;
}
template<class T1, class T2>
ostream& operator<<(ostream& os, const pair<T1, T2>& p) {
    return os << "(" << p.first << ", " << p.second << ")";
}
template<class T> 
ostream& operator<<(ostream& os, const vector<T>& v) {
    os << "[";
    for(auto e : v) os << e << ", ";
    return os << "]";
}
template<class Container> inline int SZ(Container& v) {return int(v.size());}
template<class T1, class T2> inline bool chmax(T1 &a, T2 b) {if (a < b) {a = b; return true;} return false;}
template<class T1, class T2> inline bool chmin(T1 &a, T2 b) {if (a > b) {a = b; return true;} return false;}
inline int topbit(int x) {return x == 0 ? -1 : 31 - __builtin_clz(x);}
inline int topbit(long long x) {return x == 0 ? -1 : 63 - __builtin_clzll(x);}
inline int botbit(int x) {return x == 0 ? 32 : __builtin_ctz(x);}
inline int botbit(long long x) {return x == 0 ? 64 : __builtin_ctzll(x);}
inline int popcount(int x) {return __builtin_popcount(x);}
inline int popcount(long long x) {return __builtin_popcountll(x);}
inline int kthbit(long long x, int k) {return (x>>k)&1;}
inline constexpr long long TEN(int x) {return x == 0 ? 1 : TEN(x-1) * 10;}
namespace detail {
    template<typename Tp, int Nb>
    auto make_vector(vector<int>& sizes, Tp const& x) {
        if constexpr (Nb == 1) {
            return vector(sizes[0], x);
        } else {
            int size = sizes[Nb-1];
            sizes.pop_back();
            return vector(size, make_vector<Tp, Nb-1>(sizes, x));
        }
    }
}
template<typename Tp, int Nb>
auto make_vector(int const(&sizes)[Nb], Tp const& x = Tp()) {
    vector<int> s(Nb);
    for (int i = 0; i < Nb; i++) s[i] = sizes[Nb-i-1];
    return detail::make_vector<Tp, Nb>(s, x);
}
inline void print() {cout << "\n";}
template<class T>
inline void print(const vector<T>& v) {
    for (auto itr = v.begin(); itr != v.end(); ++itr) cout << *itr << " ";
    print();
}
template<class T, class... Args>
inline void print(const T &x, const Args &... args) {
    cout << x << " ";
    print(args...);
}
#ifdef MINATO_LOCAL
#define dump(x) cerr << __LINE__ << " : " << #x << " = " << (x) << endl;
inline void debug() {cerr << endl;}
template<class T>
inline void debug(const vector<T> &v) {
    for (auto itr = v.begin(); itr != v.end(); ++itr) cerr << *itr << " ";
    debug();
}
template<class T, class... Args>
inline void debug(const T &x, const Args &... args) {
    cerr << x << " ";
    debug(args...);
}
#else
#define dump(x) void(0)
inline void debug() {}
template<class T> inline void debug(const vector<T> &v) {}
template<class T, class... Args> inline void debug(const T &x, const Args &... args) {}
#endif
struct Fast_ios {Fast_ios() {cin.tie(nullptr); ios::sync_with_stdio(false); cout << fixed << setprecision(20);};} fast_ios;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

int main() {
    int N,M; cin >> N >> M;
    vector<string> S(M);
    rep(i,N) cin >> S[i];

    int K = min(N,20);
    vector<bool> seen(1<<K);
    rep(i,M) {
        int a = 0;
        rep(j,K) {
            if (S[i][j]=='1') a |= (1<<j);
        }
        seen[a] = 1;
    }

    rep(i,1<<K) {
        if (!seen[i]) {
            string ans = "";
            rep(bit,K) {
                if (kthbit(i,bit)) ans += '1';
                else ans += '0';
            }
            while (int(ans.size()) < N) ans += '*';
            cout << ans << ln;
            return 0;
        }
    }

    cout << "hokudai" << ln;
}
accuracy: 0.14634146341463414
time_ms: 10
memory_kb: 14344
final_rank: 16

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

int main() {
    int N, M;
    cin >> N >> M; // 長さ N、M 個
    vector<string> fi(M);
    for (int i = 0; i < M; ++i) cin >> fi[i];
    
    int len = min(20, N);
    set<string> se;
    for (int i = 0; i < M; ++i) se.insert(fi[i].substr(0, len));
    string res = "";
    for (int bit = 0; bit < (1<<len); ++bit) {
        string ans = "";
        for (int i = 0; i < len; ++i) {
            if (bit & (1<<i)) ans += "1";
            else ans += "0";
        }
        if (!se.count(ans)) res = ans;
    }
    if (res == "") cout << "hokudai" << endl;
    else cout << res + string(N - len, '*') << endl;
}
accuracy: 1
time_ms: 480
memory_kb: 22340
final_rank: 11

code_snippet: #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#define repeat(i, n) for (int i = 0; (i) < (n); ++(i))
#define repeat_from(i, m, n) for (int i = (m); (i) < (n); ++(i))
#define sz(x) int(x.size())
using namespace std;
template <class T>
void setmax(T &a, T const &b) {
    if (a < b) a = b;
}

template <class T>
void setmin(T &a, T const &b) {
    if (a > b) a = b;
}

template <typename T, typename X>
auto vectors(T a, X x) { return vector<T>(x, a); }

template <typename T, typename X, typename Y, typename... Zs>
auto vectors(T a, X x, Y y, Zs... zs) {
    auto cont = vectors(a, y, zs...);
    return vector<decltype(cont)>(x, cont);
}

// N >= 20なら、
// m <= 125000
// また、0と1のどちらかを20個ならべる通りは2^20 = 1048576通り
// 2^20 > mになるので、先頭20個のパターンをすべて調べて、
// 使われていない並びをtの先頭20文字に使って、他は'*'

int main() {
    int N, M;
    cin >> N >> M;
    vector<string> S(M);
    repeat(i, M) cin >> S[i];
    int L = min(20, N);
    vector<bool> used(1 << L);
    for (int i = 0; i < M; ++i) {
        int v = 0;
        for (int j = 0; j < L; ++j) {
            if (S[i][j] == '1') {
                v |= 1 << j;
            }
        }
        used[v] = true;
    }
    int last = -1;
    for (int i = 0; i < (1 << L); ++i) {
        if (used[i]) continue;
        last = i;
    }
    string ans(N, '*');
    for (int i = 0; i < L; ++i) {
        if ((last >> i) & 1) {
            ans[i] = '1';
        } else {
            ans[i] = '0';
        }
    }
    cout << ans << endl;
    return 0;
}
accuracy: 1
time_ms: 90
memory_kb: 11860
final_rank: 10

code_snippet: // n <= 20
// bool used[1<<n]
// s_i = 1010...01 -> 数字200489
// used[s_i] = true
// used[x] = falseになってるやつ出力

// n > 20
// 文字列tに'*'を含める必要あり
// 2^n > 2^20 = 1048576
// m > 2500000/20 = 125000
// 2^n > m therfore かならず条件満たす出力はだせる？
// 文字列tの中で
// '*'をどこにするか
// '1', '0'をどこにするか
// m個の文字列{s_i}のj文字目を見て行って、
// すべて'0' -> tのj文字目を'1'にして、他は'*'
//       '1' ->            '0'にして、他は'*'

#include <bits/stdc++.h>
using namespace std;
template<typename T>
T sz(T& x){return x.size(); }

string i2bit(int n, int keta) {
  string s = "";
  while(n > 0) {
    if(n & 1) s += '1';
    else s += '0';
    n >>= 1;
  }
  while(s.size() < keta) s += '0';
  reverse(s.begin(), s.end());
  return s;
}

int main() {
  int n, m;
  cin >> n >> m;
  vector<string> vs(m);
  for(int i = 0; i < m; ++i) {
    cin >> vs[i];
  }
  if(n <= 20) {
    vector<bool> used(1<<n);
    for(string& s : vs) {
      int num = stoi(s, nullptr, 2);
      //cout << num << endl;
      used[num] = true;
    }
    for(int i = 0; i < (1<<n); ++i) {
      if(!used[i]) {
        cout << i2bit(i, n) << endl;
        return 0;
      }
    }
  } else {
    // n > 20
    string t(n, '*');
    for(int i = 0; i < n; ++i){
      int num0 = 0;
      for(int j = 0; j < m; ++j) {
        if(vs[j][i] == '0') ++num0;
      }
      if(num0 == m) {
        t[i] = '1';
        cout << t << endl;
        return 0;
      } else if(num0 == 0) {
        t[i] = '0';
        cout << t << endl;
        return 0;
      }
    }
    cout << "hokudai" << endl;
  }
  return 0;
}
accuracy: 0.24390243902439024
time_ms: 40
memory_kb: 7820
final_rank: 12

code_snippet: // n <= 20
// bool used[1<<n]
// s_i = 1010...01 -> 数字200489
// used[s_i] = true
// used[x] = falseになってるやつ出力

// n > 20
// 文字列tに'*'を含める必要あり
// 2^n > 2^20 = 1048576
// m > 2500000/20 = 125000
// 2^n > m therfore かならず条件満たす出力はだせる？
// 文字列tの中で
// '*'をどこにするか
// '1', '0'をどこにするか
// m個の文字列{s_i}のj文字目を見て行って、
// すべて'0' -> tのj文字目を'1'にして、他は'*'
//       '1' ->            '0'にして、他は'*'

#include <bits/stdc++.h>
using namespace std;
template<typename T>
T sz(T& x){return x.size(); }

string i2bit(int n, int keta) {
  string s = "";
  while(n > 0) {
    if(n & 1) s += '1';
    else s += '0';
    n >>= 1;
  }
  while(s.size() < keta) s += '0';
  reverse(s.begin(), s.end());
  return s;
}

int main() {
  int n, m;
  cin >> n >> m;
  vector<string> vs(m);
  for(int i = 0; i < m; ++i) {
    cin >> vs[i];
  }
  if(n <= 20) {
    vector<bool> used(1<<n);
    for(string& s : vs) {
      int num = stoi(s, nullptr, 2);
      //cout << num << endl;
      used[num] = true;
    }
    for(int i = 0; i < (1<<n); ++i) {
      if(!used[i]) {
        cout << i2bit(i, n) << endl;
        return 0;
      }
    }
  } else {
    // n > 20
    string t(n, '*');
    for(int i = 0; i < n; ++i){
      int num0 = 0;
      for(int j = 0; j < m; ++j) {
        if(vs[j][i] == '0') ++num0;
      }
      if(num0 == m) {
        t[i] = '0';
        cout << t << endl;
        return 0;
      } else if(num0 == 0) {
        t[i] = '1';
        cout << t << endl;
        return 0;
      }
    }
    cout << "hokudai" << endl;
  }
  return 0;
}
accuracy: 0.024390243902439025
time_ms: 40
memory_kb: 7740
final_rank: 20