QOJ.ac
QOJ
ID | Problem | Submitter | Result | Time | Memory | Language | File size | Submit time | Judge time |
---|---|---|---|---|---|---|---|---|---|
#294275 | #7788. Rook Detection | Crysfly | AC ✓ | 1259ms | 5376kb | C++14 | 5.4kb | 2023-12-30 11:11:14 | 2023-12-30 11:11:15 |
Judging History
answer
// what is matter? never mind.
//#pragma GCC optimize("Ofast")
//#pragma GCC optimize("unroll-loops")
//#pragma GCC target("sse,sse2,sse3,sse4,popcnt,abm,mmx,avx,avx2")
#include<bits/stdc++.h>
#define For(i,a,b) for(int i=(a);i<=(b);++i)
#define Rep(i,a,b) for(int i=(a);i>=(b);--i)
#define ll long long
//#define int long long
#define ull unsigned long long
using namespace std;
inline int read()
{
char c=getchar();int x=0;bool f=0;
for(;!isdigit(c);c=getchar())f^=!(c^45);
for(;isdigit(c);c=getchar())x=(x<<1)+(x<<3)+(c^48);
if(f)x=-x;return x;
}
#define fi first
#define se second
#define pb push_back
#define mkp make_pair
typedef pair<int,int>pii;
typedef vector<int>vi;
#define fi first
#define se second
#define pb push_back
#define mkp make_pair
typedef pair<int,int>pii;
typedef vector<int>vi;
#define maxn 500005
#define inf 0x3f3f3f3f
bool isr,isi;
int n,lg,qcnt;
bool a[505][505],res[505][505],b[505][505];
void ask(){
++qcnt;
cout<<"?"<<endl;
For(i,1,n){
For(j,1,n)cout<<a[i][j];
cout<<endl;
}
int x;cin>>x;
if(x==1){
if(!isr){
while(1);
}else{
exit(233);
}
}
For(i,1,n){
string s;cin>>s;
For(j,1,n)b[i][j]=(s[j-1]&1),a[i][j]=0;
}
}
bool hav[505];
bool don[505];
vi buc[505];
void answer(){
int sum=0;
For(i,1,n)For(j,1,n)sum+=res[i][j];
if(sum<n){
if(isi){
while(1);
}
else assert(0);
}
cout<<"!"<<endl;
For(i,1,n){
For(j,1,n)cout<<res[i][j];
cout<<endl;
}
int x;cin>>x;
// assert(x==0);
}
vi split(vi o,int l,int r){
vi p;
For(i,l,r) p.pb(o[i]);
return p;
}
void rows(int x){
isr=1;
For(i,1,n){
buc[i].clear();
For(j,1,n)if(j!=x)buc[i].pb(j);
// cout<<"sz "<<buc[i].size()<<"\n";
}
while(1){
bool ok=1;
For(i,1,n){
if(!buc[i].size())continue;
if(buc[i].size()==1){
res[buc[i][0]][i]=1;
continue;
}
ok=0;
}
if(ok){
answer();
break;
}
For(i,1,n){
if(buc[i].size()>1){
int mid=(buc[i].size()-1)>>1;
a[x][i]=1;
For(j,mid+1,buc[i].size()-1) a[buc[i][j]][i]=1;
}
}
ask();
For(i,1,n){
if(buc[i].size()>1){
int mid=(buc[i].size()-1)>>1;
if(b[x][i]) buc[i]=split(buc[i],mid+1,buc[i].size()-1);
else buc[i]=split(buc[i],0,mid);
}
}
}
}
bool use[505];
void work(int ID)
{
cin>>n;
lg=0;qcnt=0;isi=0;
while((1<<lg)<n)++lg;
isr=0;
For(i,1,n)For(j,1,n)res[i][j]=a[i][j]=0;
For(i,1,n)hav[i]=use[i]=don[i]=0;
// if(ID==5){
// For(i,1,n){
// a[3][i]=1;
// ask();
// }exit(0);
// }
/*
ABBB
AABB
ABAB
ABBA
*/
For(i,1,n)For(j,1,n)if(i==j||j==1)a[i][j]=1;
a[1][1]=0;
ask();
if(!b[1][1]){
rows(1);
return;
}
int pos=0;
For(i,2,n)
if(!b[i][i])pos=i;
else hav[i]=1,a[i][1]=1;
bool spe=0;
if(!pos){
/*
BAAA
ABBB
ABBB
ABBB
*/
For(i,2,n) a[1][i]=1;
ask();
if(b[1][1])res[1][1]=hav[1]=1;
if(hav[1]){
For(i,2,n) a[i][i]=1;
ask();
For(i,2,n) {
if(b[i][i])res[i][i]=1;
else res[i][1]=1;
}
answer();
return;
}
else spe=1;
}else{
a[pos][pos]=a[1][1]=a[1][pos]=1;
ask();
For(i,2,n){
if(!hav[i] && !b[i][1]){
rows(i);
return;
}
}
if(b[pos][pos]) res[1][pos]=hav[1]=1;
else if(b[1][pos]) res[1][1]=hav[1]=1;
// else : res[1][1]=0
}
vi o;
For(i,2,n) if(hav[i]) o.pb(i);
For(i,2,n) if(!hav[i]) o.pb(i);
// cout<<"o: ";for(auto x:o)cout<<x<<" "; cout<<"\n";
For(i,1,n)
if(!hav[i]) buc[i]=o; else buc[i].clear();
int now=o.size();
int nw=now;
For(_,1,lg) nw=(nw+1)>>1;
assert(nw==1);
while(1){
bool ok=1;
int mxs=0;
For(i,1,n){
mxs=max(mxs,(int)buc[i].size());
if(!buc[i].size())continue;
if(buc[i].size()==1){
res[i][buc[i][0]]=1;
continue;
}
ok=0;
}
if(spe && mxs==2)
{
// res[1][1] empty
int u=buc[1][0],v=buc[1][1];
if(!don[u] && !don[v]){
isi=1;
a[1][1]=1,a[1][u]=1,a[u][1]=1;
a[v][v]=1;
ask();
if(b[v][v]) res[v][v]=1;
else res[v][1]=1;
if(b[1][u]) res[1][u]=1;
else res[1][v]=1;
if(b[u][1]) res[u][1]=1;
else res[u][u]=1;
answer();
return;
}
}
if(ok){
bool ok2=1;
For(i,2,n)
if(hav[i] && (!res[i][1]&&!res[i][i])) ok2=0;
if(!ok2){
For(i,2,n)
if(hav[i]) a[i][i]=1;
ask();
For(i,2,n)
if(b[i][i]) res[i][i]=1;
else res[i][1]=1;
}
answer();
break;
}
For(i,1,n) use[i]=0;
For(i,1,n)
if(buc[i].size()>1){
int mid=(buc[i].size()-1)>>1;
a[i][1]=1;
// For(j,mid+1,buc[i].size()-1)cout<<"VIS "<<buc[i][j]<<"\n";
For(j,mid+1,buc[i].size()-1) a[i][buc[i][j]]=1,use[buc[i][j]]=1;
}
For(i,2,n)
if(hav[i] && !use[i]) a[i][i]=1;
assert(mxs<=now);
if(qcnt+1<=lg+2){
}
// assert(qcnt+1<=lg+2);
ask();
For(i,1,n){
if(buc[i].size()>1){
int mid=(buc[i].size()-1)>>1;
if(b[i][1]) buc[i]=split(buc[i],mid+1,buc[i].size()-1);
else buc[i]=split(buc[i],0,mid);
}
}
For(i,2,n)
if(hav[i] && !use[i]){
if(b[i][i]) res[i][i]=1;
else res[i][1]=1;
don[i]=1;
}
int mxs2=0;
For(i,1,n) mxs2=max(mxs2,(int)buc[i].size());
assert(mxs2<=(mxs+1)/2);
now=(now+1)/2;
}
}
signed main()
{
int T;cin>>T;
For(_,1,T)work(_);
return 0;
}
/*
010
111
110
0
100
100
101
1
111
111
101
111
010
010
*/
这程序好像有点Bug,我给组数据试试?
Details
Tip: Click on the bar to expand more detailed information
Test #1:
score: 100
Accepted
time: 1ms
memory: 3460kb
input:
1 3 0 111 101 111 0 111 111 101 0 111 001 110 0
output:
? 000 110 101 ? 110 010 100 ? 000 110 001 ! 010 001 100
result:
ok correct! (1 test case)
Test #2:
score: 0
Accepted
time: 81ms
memory: 3496kb
input:
9898 3 0 111 110 111 0 111 111 111 0 111 111 111 0 3 0 111 111 111 0 011 111 111 0 111 111 111 0 3 0 111 111 111 0 011 111 111 0 001 011 111 0 3 0 111 101 111 0 101 101 111 0 001 001 110 0 3 0 111 111 010 0 111 111 111 0 111 111 010 0 3 0 111 111 111 0 011 111 111 0 111 011 110 0 3 0 111 111 111 0 1...
output:
? 000 110 101 ? 011 100 100 ? 000 010 001 ! 100 010 001 ? 000 110 101 ? 011 100 100 ? 110 100 001 ! 010 100 001 ? 000 110 101 ? 011 100 100 ? 110 100 001 ! 001 010 001 ? 000 110 101 ? 110 010 100 ? 110 110 001 ! 001 001 100 ? 000 110 101 ? 101 100 001 ? 000 010 101 ! 001 010 010 ? 000 110 101 ? 011 ...
result:
ok correct! (9898 test cases)
Test #3:
score: 0
Accepted
time: 104ms
memory: 3472kb
input:
10000 4 0 1111 1011 1111 1111 0 1111 1111 1111 1111 0 1111 0011 1111 1111 0 1111 1111 1111 1111 0 4 0 1111 1111 1111 1110 0 1111 1111 1111 1111 0 1111 1111 1101 0110 0 1111 1111 1111 0101 0 4 0 1111 1011 1111 1111 0 1111 1111 1111 1111 0 1111 0011 1111 1111 0 1111 0110 1111 1111 0 4 0 1111 1011 1111...
output:
? 0000 1100 1010 1001 ? 1100 0100 1000 1000 ? 0000 1100 0010 0001 ? 0000 1001 0010 0000 ! 0100 0001 0010 0001 ? 0000 1100 1010 1001 ? 1001 1000 1000 0001 ? 0000 0100 0010 1001 ? 0000 0100 0000 1010 ! 0001 0100 1000 0100 ? 0000 1100 1010 1001 ? 1100 0100 1000 1000 ? 0000 1100 0010 0001 ? 0000 1001 00...
result:
ok correct! (10000 test cases)
Test #4:
score: 0
Accepted
time: 135ms
memory: 3456kb
input:
10000 4 0 1111 1111 1111 1111 0 0111 1111 1111 1111 0 1111 1111 1111 1111 0 1111 1111 1111 1111 0 4 0 1111 1011 1111 1111 0 1111 1011 1111 1111 0 1111 0011 1111 1110 0 1111 0110 1111 1111 0 4 0 1111 1111 1111 1111 0 0111 1101 1101 1111 0 1111 1011 1101 1111 0 1111 1011 1101 1111 0 4 0 1111 1111 1111...
output:
? 0000 1100 1010 1001 ? 0111 1000 1000 1000 ? 1001 0100 0010 0000 ? 0000 0100 0010 0001 ! 0001 0100 0010 0001 ? 0000 1100 1010 1001 ? 1100 0100 1000 1000 ? 0000 1100 0010 0001 ? 0000 1001 0010 0000 ! 1000 0010 0010 1000 ? 0000 1100 1010 1001 ? 0111 1000 1000 1000 ? 1001 0100 0010 0000 ? 0000 0100 00...
result:
ok correct! (10000 test cases)
Test #5:
score: 0
Accepted
time: 158ms
memory: 3456kb
input:
10000 4 0 1111 1111 1111 1111 0 1111 1111 1111 1111 0 1111 1011 1111 1111 0 4 0 1111 1111 1101 1111 0 1111 1111 1111 1111 0 1111 1011 0101 1110 0 1111 1011 1111 1111 0 4 0 1111 1111 1111 1101 0 1111 1111 1111 1111 0 1111 1011 1111 1110 0 4 0 1111 1101 1011 1001 0 0111 1111 1111 1111 0 1001 1111 1111...
output:
? 0000 1100 1010 1001 ? 0111 1000 1000 1000 ? 0000 0100 0010 0001 ! 1000 1000 0010 0001 ? 0000 1100 1010 1001 ? 1010 1000 0010 1000 ? 0000 0100 1010 0001 ? 0000 0100 1001 0000 ! 0010 1000 0001 1000 ? 0000 1100 1010 1001 ? 0111 1000 1000 1000 ? 0000 0100 0010 0001 ! 1000 1000 0010 1000 ? 0000 1100 10...
result:
ok correct! (10000 test cases)
Test #6:
score: 0
Accepted
time: 130ms
memory: 3464kb
input:
10000 4 0 1111 1111 1111 1111 0 0111 1111 1111 1111 0 0110 1111 1101 1111 0 1111 1111 1111 1111 0 4 0 1111 1111 1111 1110 0 1111 1111 1111 1111 0 1111 1011 1111 0110 0 1111 1011 1111 1111 0 4 0 1111 1111 1111 1110 0 1111 1111 1111 1111 0 1111 1111 1111 0110 0 1111 1111 1111 1111 0 4 0 1111 1111 1111...
output:
? 0000 1100 1010 1001 ? 0111 1000 1000 1000 ? 1001 0100 0010 0000 ? 1010 0100 0000 0001 ! 0010 0100 1000 0001 ? 0000 1100 1010 1001 ? 1001 1000 1000 0001 ? 0000 0100 0010 1001 ? 0000 0100 0000 1010 ! 0001 1000 0010 0010 ? 0000 1100 1010 1001 ? 1001 1000 1000 0001 ? 0000 0100 0010 1001 ? 0000 0100 00...
result:
ok correct! (10000 test cases)
Test #7:
score: 0
Accepted
time: 934ms
memory: 4552kb
input:
7368 4 0 1111 1111 1111 1111 0 0111 1111 1111 1111 0 1111 1111 1111 1111 0 1111 1111 1111 1111 0 4 0 1111 1111 1111 1111 0 0111 1111 1111 1111 0 0110 1011 1111 1111 0 0101 1011 1111 1111 0 4 0 1111 1111 1111 1111 0 0111 1111 1111 1111 0 1111 1111 1111 1111 0 1111 1111 1111 1111 0 4 0 1111 1111 1111 ...
output:
? 0000 1100 1010 1001 ? 0111 1000 1000 1000 ? 1001 0100 0010 0000 ? 0000 0100 0010 0001 ! 0001 0100 0010 0001 ? 0000 1100 1010 1001 ? 0111 1000 1000 1000 ? 1001 0100 0010 0000 ? 1010 0100 0000 0001 ! 0100 1000 0010 0001 ? 0000 1100 1010 1001 ? 0111 1000 1000 1000 ? 1001 0100 0010 0000 ? 0000 0100 00...
result:
ok correct! (7368 test cases)
Test #8:
score: 0
Accepted
time: 734ms
memory: 5144kb
input:
10000 9 0 111111111 101111111 110111111 111111111 111101111 111110111 111111111 111111111 111111111 0 111110111 111111111 111111111 111111111 111111111 111110111 111111111 111111111 111111111 0 111111110 111111110 010110111 111111111 010110111 010110111 111111011 111111101 111111111 0 011110111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100001000 000000000 000000000 100000000 000000000 000001000 100000000 100000000 100000000 ? 111011000 111011000 111011000 000100000 111011000 111011000 000000100 000000010 000000001 ? 100011000 100011000 10...
result:
ok correct! (10000 test cases)
Test #9:
score: 0
Accepted
time: 691ms
memory: 4492kb
input:
10000 5 0 11111 10111 11111 11111 11111 0 11111 10111 11111 11111 11111 0 11111 00110 11011 11111 11111 0 11111 11111 11011 11111 11110 0 8 0 11111111 10111111 11111111 11111111 11110111 11111011 11111111 11111111 0 11111111 11111111 11111111 11111111 11111111 11111011 11111111 11111111 0 11111111 0...
output:
? 00000 11000 10100 10010 10001 ? 11000 01000 10000 10000 10000 ? 00000 11001 00100 00010 00000 ? 00000 10010 00100 00000 00001 ! 10000 00010 10000 00010 10000 ? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10000100 00000000 10000000 10000000 00000000 00000100 10000000 1...
result:
ok correct! (10000 test cases)
Test #10:
score: 0
Accepted
time: 586ms
memory: 4436kb
input:
10000 9 0 111111111 111111111 111111111 111011111 111101111 111111111 111111111 111111111 111111111 0 111111111 111111111 111111111 111111111 111101111 111111111 111111111 111111111 111111111 0 111111111 101111111 110111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 1011...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100010000 100000000 100000000 000000000 000010000 100000000 100000000 100000000 100000000 ? 000000000 010000000 001000000 100110011 100110011 000001000 000000100 000000000 000000000 ? 000000000 010000000 00...
result:
ok correct! (10000 test cases)
Test #11:
score: 0
Accepted
time: 717ms
memory: 4364kb
input:
10000 4 0 1111 1111 1111 1111 0 1111 1111 1111 1111 0 1111 1011 1111 1111 0 6 0 111111 111111 111111 111111 111111 111111 0 111111 111111 111111 111111 111111 111111 0 111111 111111 111111 111111 111111 111111 0 6 0 111111 111111 111111 111111 111101 111111 0 111111 111111 111111 111111 111111 11111...
output:
? 0000 1100 1010 1001 ? 0111 1000 1000 1000 ? 0000 0100 0010 0001 ! 1000 1000 0010 0001 ? 000000 110000 101000 100100 100010 100001 ? 011111 100000 100000 100000 100000 100000 ? 000000 010000 001000 000100 000010 000001 ! 100000 010000 001000 000100 000010 000001 ? 000000 110000 101000 100100 100010...
result:
ok correct! (10000 test cases)
Test #12:
score: 0
Accepted
time: 360ms
memory: 4192kb
input:
10000 6 0 111111 111111 111111 111111 111111 111111 0 111111 111111 111111 111111 111111 111111 0 111111 111111 111111 111111 111111 111111 0 9 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 111111111 111111111 111111111 111111111 111111111 11...
output:
? 000000 110000 101000 100100 100010 100001 ? 011111 100000 100000 100000 100000 100000 ? 000000 010000 001000 000100 000010 000001 ! 100000 010000 001000 000100 000010 000001 ? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 011111111 100000000 100000000 ...
result:
ok correct! (10000 test cases)
Test #13:
score: 0
Accepted
time: 469ms
memory: 4956kb
input:
10000 6 0 111111 101111 110111 111011 100010 111110 0 100011 111111 111111 111111 100010 111110 0 111111 011010 011010 011010 111101 011010 0 111111 010111 010111 010111 111101 010111 0 111111 001111 001111 001111 111101 001111 0 8 0 11111111 11000110 10100110 11101111 10001110 11111011 10000110 111...
output:
? 000000 110000 101000 100100 100010 100001 ? 100001 000000 000000 000000 100000 000001 ? 000000 100101 100101 100101 000010 100101 ? 000000 101000 101000 101000 000010 101000 ? 000000 110000 110000 110000 000010 110000 ! 100000 000010 000010 000010 100000 000010 ? 00000000 11000000 10100000 1001000...
result:
ok correct! (10000 test cases)
Test #14:
score: 0
Accepted
time: 489ms
memory: 5044kb
input:
10000 6 0 111111 001111 010111 011011 011101 011110 0 111111 011111 111111 011111 011111 011110 0 111111 000000 111111 111111 000000 000000 0 111111 000000 111111 000000 111111 111111 0 111111 000101 111111 111010 111010 111010 0 9 0 011101111 101101111 110101111 111001111 111111111 111100111 111101...
output:
? 000000 110000 101000 100100 100010 100001 ? 100001 000000 000000 000000 000000 000001 ? 000000 111111 000000 000000 111111 111111 ? 000000 111111 000000 111111 000000 000000 ? 000000 111111 111111 000000 000000 000000 ! 111010 000000 000101 000000 000000 000000 ? 000000000 110000000 101000000 1001...
result:
ok correct! (10000 test cases)
Test #15:
score: 0
Accepted
time: 601ms
memory: 4816kb
input:
10000 9 0 111111111 111111111 111111111 111111111 111111111 111110111 111111011 111111111 111111110 0 111111111 111111111 111111111 111111111 111111111 111111111 011111111 111111111 011111111 0 111111111 111111111 111111111 111111111 111111111 111111111 110111011 111111111 110111011 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100000001 100000000 100000000 100000000 100000000 000000000 000000000 100000000 000000001 ? 000000000 000000000 000000000 000000000 111111111 111111111 111111111 111111111 111111111 ? 000000000 000000000 00...
result:
ok correct! (10000 test cases)
Test #16:
score: 0
Accepted
time: 459ms
memory: 4556kb
input:
10000 7 0 1111111 1111111 1010000 1111111 1111111 1111111 1111111 0 1111111 1111111 1111111 1111111 1111111 1111111 1111111 0 1111111 1011111 1111111 1110111 1111011 1111101 1111110 0 7 0 1111111 1011111 1111111 1111111 1111011 1111111 1111111 0 1111111 0111111 1111111 1111111 0111111 1111111 111111...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 0111111 1000000 1000000 1000000 1000000 1000000 1000000 ? 0000000 0100000 0010000 0001000 0000100 0000010 0000001 ! 1000000 1000000 0010000 1000000 1000000 1000000 1000000 ? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1000100 ...
result:
ok correct! (10000 test cases)
Test #17:
score: 0
Accepted
time: 577ms
memory: 5024kb
input:
10000 9 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 111111111 111111111 111011111 111111111 111111111 111111111 111111111 111111110 0 8 0 11111111 1...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 011111111 100000000 100000000 100000000 100000000 100000000 100000000 100000000 100000000 ? 000000000 010000000 001000000 000100000 000010000 000001000 000000100 000000010 000000001 ! 100000000 010000000 00...
result:
ok correct! (10000 test cases)
Test #18:
score: 0
Accepted
time: 989ms
memory: 5288kb
input:
10000 9 0 010111111 100111111 111111111 111011111 110101111 110110111 110111011 110111101 110111110 0 000000000 111111111 111111111 111111111 111111111 000000000 000000000 000000000 000000000 0 010010001 101101110 111111111 111111111 010010001 101101110 101101110 101101110 101101110 0 101101110 0100...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 111111111 000000000 000000000 000000000 000000000 111111111 111111111 111111111 111111111 ? 111111111 000000000 000000000 111111111 111111111 000000000 000000000 000000000 000000000 ? 111111111 000000000 10...
result:
ok correct! (10000 test cases)
Test #19:
score: 0
Accepted
time: 1097ms
memory: 5324kb
input:
10000 8 0 11111111 10111111 11011111 11101111 11111111 10110111 11111101 11111111 0 10110111 11111111 11111111 11111111 11111111 11111111 11111101 11111111 0 11111111 11111111 01111101 10110111 11110111 11111111 10110111 11111110 0 11111111 01111101 11110111 01111101 11110111 11111111 01111101 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10000010 00000000 00000000 00000000 10000000 10000000 00000010 10000000 ? 00000000 10110010 10110010 10110010 00001000 00000100 10110010 00000001 ? 00000000 10000010 11000001 10000010 00001000 00000100 10000010 00000000 ? 00...
result:
ok correct! (10000 test cases)
Test #20:
score: 0
Accepted
time: 887ms
memory: 5308kb
input:
10000 7 0 1111111 0011111 0101111 0110111 0111011 0111101 0111110 0 0111110 1111111 1111111 1111111 1111111 1111111 1111110 0 1111111 0111101 1010111 1111111 0111101 1010111 1010111 0 0111111 0110111 1111111 1111111 0110111 0111111 0111111 0 0111101 1010101 1111111 1111111 1010101 0111101 0111101 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1000001 0000000 0000000 0000000 0000000 0000000 0000001 ? 1000111 1000111 1000111 1000111 1000111 1000111 1000111 ? 1000001 1001000 1000001 1000001 1001000 1000001 1000001 ? 1000010 1010000 0000000 0000000 1010000 1000010 1000010 ! 0000100 ...
result:
ok correct! (10000 test cases)
Test #21:
score: 0
Accepted
time: 912ms
memory: 4888kb
input:
10000 9 0 010111111 100111111 111111111 110011111 110101111 110110111 110111011 110111101 110111110 0 000000000 111111111 111111111 111111111 111111111 000000000 000000000 000000000 000000000 0 000000000 111111111 111111111 000000000 000000000 111111111 111111111 111111111 111111111 0 111111111 0000...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 111111111 000000000 000000000 000000000 000000000 111111111 111111111 111111111 111111111 ? 111111111 000000000 000000000 111111111 111111111 000000000 000000000 000000000 000000000 ? 111111111 000000000 11...
result:
ok correct! (10000 test cases)
Test #22:
score: 0
Accepted
time: 995ms
memory: 5304kb
input:
10000 9 0 111111111 111111111 111111111 100101000 111111111 100001000 111111111 111111111 111111111 0 111111111 111111111 111111111 100001000 111111111 111111111 111111111 111111111 111111111 0 111111111 101111111 110111111 111011111 111101111 111111111 111111011 111111101 111111110 0 7 0 1111111 00...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 011111111 100000000 100000000 100000000 100000000 100000000 100000000 100000000 100000000 ? 000000000 010000000 001000000 000100000 000010000 000001000 000000100 000000010 000000001 ! 100000000 100000000 10...
result:
ok correct! (10000 test cases)
Test #23:
score: 0
Accepted
time: 710ms
memory: 5308kb
input:
10000 6 0 111111 111111 111111 111011 111101 111110 0 111111 111111 111111 011111 011111 011111 0 111111 111111 111111 000000 000000 000000 0 111111 111111 111111 111111 111111 111111 0 7 0 0111111 1011111 1101111 1110111 1111011 1111111 1111111 0 1111111 0000000 0000000 0000000 1111111 1111111 1111...
output:
? 000000 110000 101000 100100 100010 100001 ? 100001 100000 100000 000000 000000 000001 ? 000000 000000 000000 111111 111111 111111 ? 000000 000000 111111 111111 000000 000000 ! 000000 000000 111111 000000 000000 000000 ? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1111111 0000000 0000...
result:
ok correct! (10000 test cases)
Test #24:
score: 0
Accepted
time: 359ms
memory: 4120kb
input:
10000 5 0 11111 00111 01011 01101 01110 0 11111 11111 11111 11111 11110 0 11111 01111 01111 11111 11111 0 11111 11110 01111 11011 01111 0 5 0 11111 10111 11011 11101 11111 0 11111 11111 11111 11111 11101 0 11111 11111 01101 01101 11110 0 11111 01101 11111 01111 11110 0 5 0 11111 11011 11111 11101 11...
output:
? 00000 11000 10100 10010 10001 ? 10001 00000 00000 00000 00001 ? 00000 10011 10011 10011 10011 ? 00000 10100 10100 10001 10001 ! 10000 00100 01000 00001 00010 ? 00000 11000 10100 10010 10001 ? 10010 00000 00000 00010 10000 ? 00000 10110 10110 10110 00001 ? 00000 10010 11000 11000 00001 ! 00010 0010...
result:
ok correct! (10000 test cases)
Test #25:
score: 0
Accepted
time: 469ms
memory: 4120kb
input:
10000 6 0 111111 101111 110111 111111 111011 111110 0 111110 111111 111111 111111 111111 111110 0 111011 011111 111011 110110 111101 011111 0 011111 011111 101011 101110 111101 111010 0 111111 111011 111111 111101 111111 111111 0 6 0 111111 111111 110111 111011 111101 111110 0 111110 111111 111111 1...
output:
? 000000 110000 101000 100100 100010 100001 ? 100001 000000 000000 100000 100000 000001 ? 101001 101001 101001 000100 000010 101001 ? 100001 110000 100001 000100 000010 110000 ? 000000 100010 000000 000100 000000 000000 ! 001000 000010 000001 000100 100000 010000 ? 000000 110000 101000 100100 100010...
result:
ok correct! (10000 test cases)
Test #26:
score: 0
Accepted
time: 458ms
memory: 4132kb
input:
10000 7 0 1111111 1111111 1101111 1110111 1111011 1111101 1011111 0 1111101 1111111 1111111 1111111 1111111 1111101 1111111 0 1011111 1110001 1011111 0111111 1011111 0111111 1111110 0 0111111 1101101 1001111 1011101 0111111 0111111 1111110 0 1011110 1111010 1111111 1111111 0111111 1011011 1111111 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1000010 1000000 0000000 0000000 0000000 0000010 1000000 ? 1001110 0100000 1001110 1001110 1001110 1001110 0000001 ? 1000010 0100000 1000010 1010000 1000010 1010000 0000001 ? 1000100 0100000 0000000 0000000 1000100 1000001 0000000 ! 0000100 ...
result:
ok correct! (10000 test cases)
Test #27:
score: 0
Accepted
time: 1007ms
memory: 5268kb
input:
10000 8 0 11111111 00111111 01011111 01101111 01110111 01111011 01111101 01111110 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111110 0 11111111 11111111 11111111 01111111 11111111 01111111 01111111 01111111 0 11111111 01111111 01111111 01111111 11100111 01111111 11111110 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10000001 00000000 00000000 00000000 00000000 00000000 00000000 00000001 ? 00000000 10000111 10000111 10000111 10000111 10000111 10000111 10000111 ? 00000000 10000001 10000001 10011000 10000001 10011000 10011000 10011000 ? 00...
result:
ok correct! (10000 test cases)
Test #28:
score: 0
Accepted
time: 1127ms
memory: 5240kb
input:
10000 8 0 11111111 10111111 11011111 11110100 11111100 11111011 11110110 11110101 0 11111011 11111111 11111111 11111111 11111111 11111011 11111111 11111111 0 11110100 11110100 11110100 11101111 10011000 01111111 10010010 10010001 0 01111111 11110111 01111111 11101111 11111011 01111100 11111111 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10000100 00000000 00000000 10000000 10000000 00000100 10000000 10000000 ? 11100100 11100100 11100100 00010000 00001000 11100100 00000010 00000001 ? 10000100 10000100 10000100 00010000 00001000 10000011 00000000 00000000 ? 10...
result:
ok correct! (10000 test cases)
Test #29:
score: 0
Accepted
time: 1176ms
memory: 5312kb
input:
10000 8 0 11111111 10111111 11011111 11111011 11110111 11111111 11111101 11111110 0 11111110 11111111 11111111 11111111 11111111 11111111 11111111 11111110 0 11111011 01111111 01111111 11101111 11111011 11110100 11111011 01111111 0 01111111 01111111 11111010 11101111 01111111 10011110 10011011 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10000001 00000000 00000000 10000000 00000000 10000000 00000000 00000001 ? 10001011 10001011 10001011 00010000 10001011 00000100 10001011 10001011 ? 10000001 11100000 11100000 00010000 10000001 00000100 10000001 11100000 ? 10...
result:
ok correct! (10000 test cases)
Test #30:
score: 0
Accepted
time: 1141ms
memory: 5240kb
input:
10000 8 0 11111111 10111111 11101101 11011101 11110111 11001101 11001111 11111110 0 11111111 11111111 11111111 11111111 11111111 11111110 11111111 11111111 0 11111111 11001101 10100101 10010101 11001101 11111011 10000111 01111110 0 11111111 01111110 11101011 11011011 01111110 11111111 11111111 11001...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10000001 00000000 10000000 10000000 00000000 10000000 10000000 00000001 ? 00000000 11001001 00100000 00010000 11001001 00000100 00000010 11001001 ? 00000000 10000001 00100000 00010000 10000001 00000000 00000000 10000110 ? 00...
result:
ok correct! (10000 test cases)
Test #31:
score: 0
Accepted
time: 1030ms
memory: 5252kb
input:
10000 8 0 11111111 00111111 01011111 01101111 01110111 01111011 01111101 01111110 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111110 0 11111111 01111111 11111111 11111111 01111111 01111111 11111111 01111111 0 11111111 11111110 11100111 01111111 01111111 11111110 01111111 01111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10000001 00000000 00000000 00000000 00000000 00000000 00000000 00000001 ? 00000000 10000111 10000111 10000111 10000111 10000111 10000111 10000111 ? 00000000 10011000 10000001 10000001 10011000 10011000 10000001 10011000 ? 00...
result:
ok correct! (10000 test cases)
Test #32:
score: 0
Accepted
time: 1155ms
memory: 5292kb
input:
10000 9 0 111111111 101111111 110111111 111011111 111111111 111110111 111111011 111111101 111111110 0 111111110 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111110 0 011111111 111111111 111111111 011111111 111101111 111111111 011111111 011111111 111111111 0 011111111 0111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100000001 000000000 000000000 000000000 100000000 000000000 000000000 000000000 000000001 ? 100001111 100001111 100001111 100001111 000010000 100001111 100001111 100001111 100001111 ? 101100000 100000011 10...
result:
ok correct! (10000 test cases)
Test #33:
score: 0
Accepted
time: 1008ms
memory: 5244kb
input:
10000 9 0 111111111 111111111 010111111 011011111 011101111 011110111 011111011 011111101 011111110 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111110 0 111111111 111110000 011111111 101111111 101111111 011111111 101111111 101111111 011111111 0 111111111 1110...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100000001 100000000 000000000 000000000 000000000 000000000 000000000 000000000 000000001 ? 000000000 010000000 100001111 100001111 100001111 100001111 100001111 100001111 100001111 ? 000000000 010000000 10...
result:
ok correct! (10000 test cases)
Test #34:
score: 0
Accepted
time: 1249ms
memory: 5296kb
input:
10000 9 0 111111111 101111111 110111111 111011111 111111111 111110111 111111011 111111101 111111110 0 111111110 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111110 0 011111111 111111111 011111111 011111111 111101111 111111111 111111111 011111111 111111111 0 111111100 0111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100000001 000000000 000000000 000000000 100000000 000000000 000000000 000000000 000000001 ? 100001111 100001111 100001111 100001111 000010000 100001111 100001111 100001111 100001111 ? 101100000 100000011 10...
result:
ok correct! (10000 test cases)
Test #35:
score: 0
Accepted
time: 1092ms
memory: 5284kb
input:
10000 9 0 111111111 101111111 110111111 111011111 111101111 111110111 111111111 111111101 111111110 0 111111110 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111110 0 011111111 111111111 111111111 011111111 011111111 011111111 111111011 111111111 111111111 0 011111111 1100...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100000001 000000000 000000000 000000000 000000000 000000000 100000000 000000000 000000001 ? 100011011 100011011 100011011 100011011 100011011 100011011 000000100 100011011 100011011 ? 101100000 100000011 10...
result:
ok correct! (10000 test cases)
Test #36:
score: 0
Accepted
time: 1094ms
memory: 5292kb
input:
10000 9 0 111111111 111111011 110111111 111011111 111101111 111110111 111111111 111111101 111111110 0 111111110 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111110 0 111111011 101111111 111111011 111111011 011111111 111111011 111100100 011111111 011111111 0 011111111 1011...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100000001 100000000 000000000 000000000 000000000 000000000 100000000 000000000 000000001 ? 100011011 010000000 100011011 100011011 100011011 100011011 000000100 100011011 100011011 ? 100000011 010000000 10...
result:
ok correct! (10000 test cases)
Test #37:
score: 0
Accepted
time: 496ms
memory: 4112kb
input:
10000 7 0 1111111 1011111 1111111 1110111 1111011 1111101 1111110 0 1111110 0111111 1111111 1111111 1111111 1111111 1111110 0 1111111 0111010 1111111 1111111 1111111 1111111 1111111 0 1111111 0010011 1111111 1111111 1111111 1111111 1111110 0 1111111 1110011 1111111 1111111 1111111 1111111 1111111 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1000001 0000000 1000000 0000000 0000000 0000000 0000001 ? 0000000 1111111 0000000 0000000 1111111 1111111 1111111 ? 0000000 1111111 0000000 1000101 0000000 0000000 0111010 ? 0000000 1101100 1000100 0000000 0000000 0101000 0000000 ! 0000100 ...
result:
ok correct! (10000 test cases)
Test #38:
score: 0
Accepted
time: 495ms
memory: 4248kb
input:
10000 8 0 11111111 10111111 11111111 11111111 11110111 11111011 11111101 11111110 0 11111110 11111111 11111111 11111111 11111111 11111111 11111111 11111110 0 01111111 01111111 11011111 11111000 11111111 11111111 01111111 11111111 0 11111110 01110111 11011111 10111110 01111111 10111111 01110111 01111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10000001 00000000 10000000 10000000 00000000 00000000 00000000 00000001 ? 10000111 10000111 00100000 00010000 10000111 10000111 10000111 10000111 ? 11001000 11001000 00100000 00010000 10000001 10000001 11001000 10000001 ? 10...
result:
ok correct! (10000 test cases)
Test #39:
score: 0
Accepted
time: 488ms
memory: 4204kb
input:
10000 8 0 11111111 10111111 11011111 11101111 11110111 11111011 11111111 11111110 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 0 11111111 01111111 11111111 11111111 11111111 01111111 11111101 01111111 0 11111111 11111111 01111111 01111111 11101111 01111111 11111101 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10000001 00000000 00000000 00000000 00000000 00000000 10000000 00000001 ? 00000000 10001101 10001101 10001101 10001101 10001101 00000010 10001101 ? 00000000 10110000 10000001 10000001 10000001 10110000 00000010 10110000 ? 00...
result:
ok correct! (10000 test cases)
Test #40:
score: 0
Accepted
time: 549ms
memory: 4248kb
input:
10000 8 0 11111111 10111111 11011111 11101111 11110111 11111111 11111101 11111101 0 11111101 11111111 11111111 11111111 11111111 11111111 11111101 11111101 0 01111101 11111111 11111111 01111101 01111101 11111111 01111101 11111110 0 11111101 01111101 01111101 01111111 11111101 11111111 01111111 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10000010 00000000 00000000 00000000 00000000 10000000 00000010 10000000 ? 10011010 10011010 10011010 10011010 10011010 00000100 10011010 00000001 ? 11100000 10000010 10000010 11100000 11100000 00000100 11100000 00000001 ? 10...
result:
ok correct! (10000 test cases)
Test #41:
score: 0
Accepted
time: 1124ms
memory: 5276kb
input:
10000 9 0 111111111 111110111 010111111 011011111 111111111 111111111 011111011 011111101 011111110 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111110 0 111111111 111110000 111110111 111110111 111111111 111111000 111111111 011011111 111111111 0 111111111 1101...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100000001 100000000 000000000 000000000 100000000 100000000 000000000 000000000 000000001 ? 000000000 010000000 100100111 100100111 000010000 000001000 100100111 100100111 100100111 ? 000000000 010000000 10...
result:
ok correct! (10000 test cases)
Test #42:
score: 0
Accepted
time: 1093ms
memory: 5284kb
input:
10000 9 0 111111111 110111101 101111101 100111101 111101111 100111101 111111011 111111101 111111111 0 111111101 111111111 111111111 111111111 111111111 111111101 111111111 111111101 111111111 0 100111111 110111001 101111001 100111001 011111101 111110111 100111111 100111111 111111111 0 011111101 1101...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100000010 100000000 100000000 100000000 000000000 100000000 000000000 000000010 100000000 ? 100010111 010000000 001000000 000100000 100010111 000001000 100010111 100010111 000000000 ? 100000110 010000000 00...
result:
ok correct! (10000 test cases)
Test #43:
score: 0
Accepted
time: 1076ms
memory: 5256kb
input:
10000 9 0 111111111 101111111 111111111 111011111 111101111 111110111 111111111 111111101 111111110 0 111111110 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111110 0 011111111 011111111 111111111 111111111 111111111 011111111 111111011 111111111 111111111 0 011111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100000001 000000000 100000000 000000000 000000000 000000000 100000000 000000000 000000001 ? 100011011 100011011 001000000 100011011 100011011 100011011 000000100 100011011 100011011 ? 110100000 110100000 00...
result:
ok correct! (10000 test cases)
Test #44:
score: 0
Accepted
time: 479ms
memory: 4176kb
input:
10000 7 0 1111111 1111111 1101111 1110111 1111011 1111111 1111110 0 1111110 1111111 1111111 1111111 1111111 1111111 1111110 0 1111111 1111111 0111111 1111111 1111111 1111101 1111111 0 0111111 1111111 0101111 1111111 0111111 1111101 0111111 0 0111111 1111111 1111111 1111111 0111111 1111111 1111111 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1000001 1000000 0000000 0000000 0000000 1000000 0000001 ? 1001101 0100000 1001101 1001101 1001101 0000010 1001101 ? 1000001 0100000 1010000 1000001 1000001 0000010 1000001 ? 1000100 0100000 1000010 0000000 1000100 0000000 1000100 ! 0001000 ...
result:
ok correct! (10000 test cases)
Test #45:
score: 0
Accepted
time: 538ms
memory: 4168kb
input:
10000 8 0 11111111 11111111 11011111 11101111 11111111 11111011 11111101 11111110 0 11111110 11111111 11111111 11111111 11111111 11111111 11111111 11111110 0 11111111 10111111 11111111 01111101 11110111 01111101 11111111 01111101 0 01111111 10111111 11011111 01101111 11110111 01101111 01111111 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10000001 10000000 00000000 00000000 10000000 00000000 00000000 00000001 ? 10000111 01000000 10000111 10000111 00001000 10000111 10000111 10000111 ? 10000001 01000000 10000001 10110000 00001000 10110000 10000001 10110000 ? 10...
result:
ok correct! (10000 test cases)
Test #46:
score: 0
Accepted
time: 512ms
memory: 4128kb
input:
10000 8 0 11111111 00111111 11111111 01101111 11111111 01111011 01111101 11111111 0 11111111 11111111 11111111 11111111 11111111 11111111 11111101 11111111 0 11111111 01111101 11111111 11111111 11111111 11111111 01111101 11101111 0 11111111 00111110 11111111 01111101 11111111 01111101 00111110 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10000010 00000000 10000000 00000000 10000000 00000000 00000010 10000000 ? 00000000 10010110 00100000 10010110 00001000 10010110 10010110 00000001 ? 00000000 11000001 00100000 10000010 00001000 10000010 11000001 00000000 ? 00...
result:
ok correct! (10000 test cases)
Test #47:
score: 0
Accepted
time: 565ms
memory: 4176kb
input:
10000 8 0 11111111 10111111 11011111 11111111 11110111 11111011 11111101 11111110 0 11111110 11111111 11111111 11111111 11111111 11111111 11111111 11111110 0 11111111 11111111 11111111 11101111 11111111 01111111 11111111 11111111 0 01111111 01111111 01111111 11101111 01111111 11111110 11111111 01111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10000001 00000000 00000000 10000000 00000000 00000000 00000000 00000001 ? 10000111 10000111 10000111 00010000 10000111 10000111 10000111 10000111 ? 10000001 10000001 10000001 00010000 10000001 10101000 10000001 10000001 ? 10...
result:
ok correct! (10000 test cases)
Test #48:
score: 0
Accepted
time: 1152ms
memory: 5368kb
input:
10000 9 0 111111111 101111111 110111111 111011111 111101111 111110111 111111111 111111101 111111111 0 111111101 111111111 111111111 111111111 111111111 111111111 111111111 111111101 111111111 0 011111111 011111111 111111111 111111111 111111111 111111111 111111011 011111111 111111110 0 111111111 0011...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100000010 000000000 000000000 000000000 000000000 000000000 100000000 000000010 100000000 ? 100111010 100111010 100111010 100111010 100111010 100111010 000000100 100111010 000000001 ? 111000000 111000000 10...
result:
ok correct! (10000 test cases)
Test #49:
score: 0
Accepted
time: 1236ms
memory: 5268kb
input:
10000 9 0 111111111 111111111 111111111 111111111 111101111 111110111 111111011 111111111 111111111 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 111111111 111111111 111011111 011101010 011101010 111111101 111111111 111111111 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100000100 100000000 100000000 100000000 000000000 000000000 000000100 100000000 100000000 ? 000000000 010000000 001000000 000100000 100011101 100011101 100011101 000000010 000000000 ? 000000000 010000000 00...
result:
ok correct! (10000 test cases)
Test #50:
score: 0
Accepted
time: 1173ms
memory: 5312kb
input:
10000 9 0 111111111 111111111 110111111 111111111 111111111 111110111 111111011 111111101 111111111 0 111111101 111111111 111111111 111111111 111111111 111111111 111111111 111111101 111111111 0 111111111 111111111 111111111 111111111 111101111 111111111 011110111 111111111 111111111 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100000010 100000000 000000000 100000000 100000000 000000000 000000000 000000010 100000000 ? 101001110 010000000 101001110 000100000 000010000 101001110 101001110 101001110 000000001 ? 100000110 010000000 10...
result:
ok correct! (10000 test cases)
Test #51:
score: 0
Accepted
time: 304ms
memory: 3892kb
input:
10000 7 0 1111111 1111111 1111111 1111111 1111111 1111111 1111111 0 1111111 1111111 1111111 1111111 1111111 1111111 1111111 0 1111111 1111111 1111111 1111111 1111011 1111111 1111111 0 7 0 1111111 1111111 1111111 1111111 1111011 1111111 1111111 0 1111111 1111111 1111111 1111111 0111111 1111111 111111...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 0111111 1000000 1000000 1000000 1000000 1000000 1000000 ? 0000000 0100000 0010000 0001000 0000100 0000010 0000001 ! 1000000 0100000 0010000 0001000 1000000 0000010 0000001 ? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1000100 ...
result:
ok correct! (10000 test cases)
Test #52:
score: 0
Accepted
time: 404ms
memory: 3884kb
input:
10000 8 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 0 01111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 0 01111110 11111111 11111111 11111111 11111111 11111111 11111111 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 01111111 10000000 10000000 10000000 10000000 10000000 10000000 10000000 ? 10000111 01000000 00100000 00010000 00001000 00000000 00000000 00000000 ? 10000001 01000000 00100000 00010000 00001000 00000100 00000010 00000000 ? 10...
result:
ok correct! (10000 test cases)
Test #53:
score: 0
Accepted
time: 557ms
memory: 4116kb
input:
10000 8 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 0 11111111 10111111 11011111 11111111 11111111 11111111 11111111 11111111 0 8 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 1...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 01111111 10000000 10000000 10000000 10000000 10000000 10000000 10000000 ? 00000000 01000000 00100000 00010000 00001000 00000100 00000010 00000001 ! 10000000 10000000 10000000 00010000 00001000 00000100 00000010 00000001 ? 00...
result:
ok correct! (10000 test cases)
Test #54:
score: 0
Accepted
time: 470ms
memory: 4180kb
input:
10000 8 0 11111111 10111111 11111111 11101111 11111111 11111111 11111111 11111111 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 0 11111111 11111111 11111111 01111111 11111111 11111111 11111111 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10010000 00000000 10000000 00010000 10000000 10000000 10000000 10000000 ? 00000000 11010001 00100000 11010001 00001000 00000100 00000010 00000000 ? 00000000 10010000 00100000 10010000 00001000 00000100 00000010 00000001 ? 00...
result:
ok correct! (10000 test cases)
Test #55:
score: 0
Accepted
time: 295ms
memory: 3844kb
input:
10000 8 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 0 11111111 10111111 11111111 11111111 11111111 11111111 11111111 11111111 0 8 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 1...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 01111111 10000000 10000000 10000000 10000000 10000000 10000000 10000000 ? 00000000 01000000 00100000 00010000 00001000 00000100 00000010 00000001 ! 10000000 10000000 00100000 00010000 00001000 00000100 00000010 00000001 ? 00...
result:
ok correct! (10000 test cases)
Test #56:
score: 0
Accepted
time: 1165ms
memory: 4280kb
input:
10000 9 0 111111111 111111111 111111111 111011111 111111111 111111111 111111111 111111111 111111111 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 111111111 111111111 011011000 111111111 111110111 111111111 111111111 111111111 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100100000 100000000 100000000 000100000 100000000 100000000 100000000 100000000 100000000 ? 000000000 010000000 001000000 100100111 000010000 000001000 000000000 000000000 000000000 ? 000000000 010000000 00...
result:
ok correct! (10000 test cases)
Test #57:
score: 0
Accepted
time: 923ms
memory: 5280kb
input:
10000 9 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 101111111 111111111 111111111 111111111 111111111 111111111 111111111 111111110 0 9 0 111111111 ...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 011111111 100000000 100000000 100000000 100000000 100000000 100000000 100000000 100000000 ? 000000000 010000000 001000000 000100000 000010000 000001000 000000100 000000010 000000001 ! 100000000 100000000 00...
result:
ok correct! (10000 test cases)
Test #58:
score: 0
Accepted
time: 730ms
memory: 4268kb
input:
10000 9 0 111111111 111111111 111111111 111111111 111111111 111110111 111111111 111111111 111111111 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 101111111 110111111 111111111 111101111 111111111 111111111 111111111 111111111 0 111111111 1011...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100001000 100000000 100000000 100000000 100000000 000001000 100000000 100000000 100000000 ? 000000000 010000000 001000000 000100000 000010000 100001111 000000000 000000000 000000000 ? 000000000 010000000 00...
result:
ok correct! (10000 test cases)
Test #59:
score: 0
Accepted
time: 866ms
memory: 5220kb
input:
10000 9 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 9 0 111111111 ...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 011111111 100000000 100000000 100000000 100000000 100000000 100000000 100000000 100000000 ? 000000000 010000000 001000000 000100000 000010000 000001000 000000100 000000010 000000001 ! 100000000 010000000 00...
result:
ok correct! (10000 test cases)
Test #60:
score: 0
Accepted
time: 1090ms
memory: 4836kb
input:
10000 7 0 1111111 1111111 1111111 1111111 1111111 1111111 1111111 0 1111111 1111111 1111111 1111111 1111111 1111111 1111111 0 1111111 1111111 1111111 1111111 1111011 1111111 1111111 0 7 0 1111111 1111111 1111111 1111111 1111011 1111111 1111111 0 1111111 1111111 1111111 1111111 1111011 1111111 111111...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 0111111 1000000 1000000 1000000 1000000 1000000 1000000 ? 0000000 0100000 0010000 0001000 0000100 0000010 0000001 ! 1000000 0100000 0010000 0001000 1000000 0000010 0000001 ? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1000100 ...
result:
ok correct! (10000 test cases)
Test #61:
score: 0
Accepted
time: 917ms
memory: 4240kb
input:
10000 7 0 1111111 1011111 1111110 1110111 1111111 1111111 1111111 0 1111111 1111111 1111111 1110111 1111111 1111111 1111111 0 1111111 1111111 1101111 0011110 1111011 1111111 1111111 0 1111111 1111111 1101111 1111111 1111011 1111111 1111111 0 7 0 1111111 1111111 1111111 1111111 1111111 1111111 111111...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1001000 0000000 1000000 0001000 1000000 1000000 1000000 ? 0000000 1101001 0010000 1101001 0000100 0000010 0000000 ? 0000000 1001000 0010000 1000010 0000100 0000000 0000001 ! 1000000 0001000 1000000 0000010 1000000 0000010 0000001 ? 0000000 ...
result:
ok correct! (10000 test cases)
Test #62:
score: 0
Accepted
time: 893ms
memory: 4268kb
input:
10000 9 0 111111111 101111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 111111111 111111111 111111111 111111111 111110111 111111111 111111111 111111111 0 111111111 0011...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 110000000 010000000 100000000 100000000 100000000 100000000 100000000 100000000 100000000 ? 000000000 110000111 001000000 000100000 000010000 000001000 000000000 000000000 000000000 ? 000000000 110000001 00...
result:
ok correct! (10000 test cases)
Test #63:
score: 0
Accepted
time: 557ms
memory: 4236kb
input:
10000 8 0 11111111 11111111 11111111 11111111 11111111 11111011 11111111 11111111 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 0 11111111 10111111 11111111 11111111 11111111 11111111 11111111 11111111 0 11111111 10111111 11111111 11111111 11111111 01111011 11111111 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10000100 10000000 10000000 10000000 10000000 00000100 10000000 10000000 ? 00000000 01000000 00100000 00010000 00001000 10000111 00000000 00000000 ? 00000000 01000000 00100000 00010000 00001000 10000100 00000010 00000001 ? 00...
result:
ok correct! (10000 test cases)
Test #64:
score: 0
Accepted
time: 605ms
memory: 4236kb
input:
10000 9 0 111111111 101111111 111111111 111011111 111101111 111110111 111111111 111111111 111111110 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 011111111 111111111 111111111 111111111 111111111 111111111 111111101 111111111 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100000001 000000000 100000000 000000000 000000000 000000000 100000000 100000000 000000001 ? 000000000 100111001 001000000 100111001 100111001 100111001 000000100 000000010 100111001 ? 000000000 110000010 00...
result:
ok correct! (10000 test cases)
Test #65:
score: 0
Accepted
time: 766ms
memory: 4948kb
input:
10000 6 0 111111 101111 110111 111100 111101 111101 0 111101 111111 111111 111111 111101 111111 0 011101 111110 011101 110100 011101 111111 0 011111 011101 111100 101100 011111 111111 0 011110 111111 111111 111101 011110 111111 0 6 0 111111 001111 010111 011011 011101 011110 0 101111 111111 111111 1...
output:
? 000000 110000 101000 100100 100010 100001 ? 100010 000000 000000 100000 000010 100000 ? 101010 101010 101010 000100 101010 000001 ? 110000 100010 110000 000100 110000 000001 ? 100001 000000 000000 000100 100001 000000 ! 000100 001000 010000 000100 000100 000001 ? 000000 110000 101000 100100 100010...
result:
ok correct! (10000 test cases)
Test #66:
score: 0
Accepted
time: 470ms
memory: 4164kb
input:
10000 7 0 1111111 1110010 1101111 1111010 1111011 1111101 1110011 0 1111010 1111010 1111111 1111111 1111111 1111101 1111010 0 1111111 1011111 1110110 1101000 1110110 0111011 1111110 0 1111111 1011111 1110010 1111000 0111111 0111110 1111111 0 1111111 1011111 1111111 1111111 0111011 0110111 1111110 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1000010 1000000 0000000 1000000 0000000 0000010 1000000 ? 0000000 0100000 1010110 0001000 1010110 1010110 0000001 ? 0000000 0100000 1000010 0001000 1000010 1000001 0000000 ? 0000000 0100000 0000000 0000000 1000100 1001000 0000001 ! 1000000 ...
result:
ok correct! (10000 test cases)
Test #67:
score: 0
Accepted
time: 463ms
memory: 4128kb
input:
10000 7 0 1111111 0011111 0101111 0110111 1111101 1111111 0111110 0 0111110 1111111 1111111 1111111 0111111 0111111 1111110 0 0100110 0100110 0100110 0100110 0111101 1111111 0100110 0 0011111 0011111 0011111 0011111 0111101 1111111 0011111 0 0111101 0111101 0111101 0111101 0111111 1111111 0111101 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1000001 0000000 0000000 0000000 1000000 1000000 0000001 ? 1011001 1011001 1011001 1011001 0000100 0000010 1011001 ? 1100000 1100000 1100000 1100000 0000100 0000010 1100000 ? 1000010 1000010 1000010 1000010 0000100 0000000 1000010 ! 0000100 ...
result:
ok correct! (10000 test cases)
Test #68:
score: 0
Accepted
time: 531ms
memory: 4220kb
input:
10000 7 0 1111111 0011111 0101111 0110111 0111011 0111101 0111110 0 1111111 1111111 1111111 1111111 1111111 1111111 1111111 0 1111111 0111000 0111000 0111000 0111000 0111000 0111000 0 1111111 0111111 1111101 0111111 0111111 1111101 1111101 0 1111111 1111101 1111111 1111101 1111101 1111111 1111111 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1000001 0000000 0000000 0000000 0000000 0000000 0000001 ? 0000000 1000111 1000111 1000111 1000111 1000111 1000111 ? 0000000 1001000 1001000 1001000 1001000 1001000 1001000 ? 0000000 1010000 0000000 1010000 1010000 0000000 0000000 ! 0000001 ...
result:
ok correct! (10000 test cases)
Test #69:
score: 0
Accepted
time: 492ms
memory: 4128kb
input:
10000 7 0 1111111 1011111 1101111 1001111 1111011 1001111 1111110 0 1111110 1111111 1111111 1001111 1111111 1111111 1111110 0 0101111 1111111 1011111 1110111 0101111 1001010 1011111 0 0011111 0111111 1001111 1110111 0011111 1001110 0111111 0 1001011 1111111 1111111 1110111 1001011 1111111 1001111 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1000001 0000000 0000000 1000000 0000000 1000000 0000001 ? 1010101 1010101 1010101 0001000 1010101 0000010 1010101 ? 1100000 1000001 1000001 0001000 1100000 0000010 1000001 ? 1000010 1000100 0000000 0001000 1000010 0000000 1000100 ! 0000010 ...
result:
ok correct! (10000 test cases)
Test #70:
score: 0
Accepted
time: 569ms
memory: 4164kb
input:
10000 8 0 11111111 10111111 11011111 11111100 11110111 11111011 11111110 11111110 0 11111110 11111111 11111111 11111110 11111111 11111111 11111111 11111110 0 01111110 11111101 11111101 11101111 01111110 01111110 11110010 01111110 0 01111111 01111110 01111110 11101111 11111100 01111111 10011110 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10000001 00000000 00000000 10000000 00000000 00000000 10000000 00000001 ? 10001101 10001101 10001101 00010000 10001101 10001101 00000010 10001101 ? 11100000 10000001 10000001 00010000 11100000 11100000 00000010 11100000 ? 10...
result:
ok correct! (10000 test cases)
Test #71:
score: 0
Accepted
time: 573ms
memory: 4192kb
input:
10000 8 0 11111111 10111111 11011111 11101111 11111111 11111011 11111101 11111110 0 11111110 11111111 11111111 11111111 11110111 11111111 11111111 11111110 0 01111111 01111111 11110111 11110111 11110111 11110111 01111111 01111111 0 01111111 11110110 01111111 01111111 11110111 11000111 11110110 11110...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10000001 00000000 00000000 00000000 10000000 00000000 00000000 00000001 ? 10000111 10000111 10000111 10000111 00001000 10000111 10000111 10000111 ? 10110000 10110000 10000001 10000001 00001000 10000001 10110000 10110000 ? 11...
result:
ok correct! (10000 test cases)
Test #72:
score: 0
Accepted
time: 486ms
memory: 4128kb
input:
10000 8 0 11111111 11111111 11011111 11101111 11111111 11111011 11111111 11111111 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 0 11111111 10111111 01001011 01001011 11111111 01001011 11111111 11111111 0 11111111 10111111 01111100 01111100 11111111 01111100 11111111 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10000100 10000000 00000000 00000000 10000000 00000100 10000000 10000000 ? 00000000 01000000 10110100 10110100 00001000 10110100 00000010 00000001 ? 00000000 01000000 10000011 10000011 00001000 10000011 00000000 00000000 ? 00...
result:
ok correct! (10000 test cases)
Test #73:
score: 0
Accepted
time: 635ms
memory: 4184kb
input:
10000 8 0 01011111 10011111 11111111 11001111 11110111 11011111 11011101 11011110 0 10000000 01111111 11111111 01111111 11111111 11111111 10000000 10000000 0 00010001 11111110 11111111 10010001 11111111 11111111 11111110 01111110 0 01111111 10010000 11111111 10010000 10010001 11111111 00010000 10010...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11111111 00000000 00000000 00000000 00000000 11111111 11111111 11111111 ? 11111111 00000000 00000000 01111111 01111111 00000000 00000000 10000000 ? 11111111 00000000 01101110 00000000 00010001 00000000 10000000 00000000 ! 00...
result:
ok correct! (10000 test cases)
Test #74:
score: 0
Accepted
time: 499ms
memory: 4176kb
input:
10000 8 0 11111111 11111111 11011111 11101111 11111111 11011101 11111111 11111111 0 11101111 11111111 11111111 11101111 11111111 11111111 11111111 11111111 0 11111111 11111111 11111111 11111111 11111111 11111111 11111101 11111111 0 01101111 11111111 01101111 01101111 11111111 11111111 11111101 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10010000 10000000 00000000 00010000 10000000 10000000 10000000 10000000 ? 10110001 01000000 10110001 10110001 00001000 00000100 00000010 00000000 ? 10010000 01000000 10010000 10010000 00001000 00000100 00000010 00000001 ? 10...
result:
ok correct! (10000 test cases)
Test #75:
score: 0
Accepted
time: 546ms
memory: 4236kb
input:
10000 8 0 11111111 10111101 11111101 11101101 11110101 11111001 11111111 11111100 0 11111110 01111111 11111111 01111111 01111111 01111111 11111111 01111110 0 11111111 01110011 11111111 10001100 10001100 01110011 11111111 01110011 0 11111111 00000000 11111111 01110011 01110011 11111111 11111111 10001...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10000001 00000000 10000000 00000000 00000000 00000000 10000000 00000001 ? 00000000 11111111 00000000 00000000 00000000 11111111 11111111 11111111 ? 00000000 11111111 00000000 10001100 10001100 00000000 00000000 01110011 ? 00...
result:
ok correct! (10000 test cases)
Test #76:
score: 0
Accepted
time: 532ms
memory: 4124kb
input:
10000 8 0 11111111 00111111 01011111 11111111 01110111 01111011 11111111 11111111 0 11111111 01111111 01111111 11111111 11111111 01111011 11111111 11111111 0 11111111 01011111 11111111 11111111 11111111 01011111 11111111 11111111 0 11111111 00011001 11111111 01011111 01011111 11111111 11111111 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10000100 00000000 00000000 10000000 00000000 00000100 10000000 10000000 ? 00000000 11111111 00000000 00000000 00000000 11111111 11111111 11111111 ? 00000000 11111111 00000000 10100000 10100000 00000000 00000000 01011111 ? 00...
result:
ok correct! (10000 test cases)
Test #77:
score: 0
Accepted
time: 1259ms
memory: 5340kb
input:
10000 9 0 111111111 101111111 110111111 110111111 111101111 111110111 111111011 111111101 111111110 0 111111111 111111111 111111111 110111110 111111111 111111111 111111111 111111111 111111111 0 111111111 110111111 110111111 111011111 011111110 011111110 110111111 110111111 110111111 0 111111111 1101...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100000001 000000000 000000000 100000000 000000000 000000000 000000000 000000000 000000001 ? 000000000 100001111 100001111 000100000 100001111 100001111 100001111 100001111 100001111 ? 000000000 100000011 10...
result:
ok correct! (10000 test cases)
Test #78:
score: 0
Accepted
time: 1239ms
memory: 5348kb
input:
10000 9 0 111111111 101111111 110111111 111111111 111101111 111110111 111111011 111111111 111111110 0 111111110 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111110 0 011111111 011111111 011111111 111011111 011111111 111111111 111111111 111100110 111111111 0 111111110 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100000001 000000000 000000000 100000000 000000000 000000000 000000000 100000000 000000001 ? 100011101 100011101 100011101 000100000 100011101 100011101 100011101 000000010 100011101 ? 111000000 111000000 11...
result:
ok correct! (10000 test cases)
Test #79:
score: 0
Accepted
time: 1061ms
memory: 5264kb
input:
10000 9 0 111111111 001111111 101111101 100111101 011101111 011110111 111111111 011111101 011111110 0 011111110 111111111 011111111 011111111 111111111 111111111 011111111 111111111 111111110 0 011101101 111111111 001110100 000110100 100111111 011101101 111111111 011101101 011101101 0 001111011 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100000001 000000000 100000000 100000000 000000000 000000000 100000000 000000000 000000001 ? 100011011 100011011 001000000 000100000 100011011 100011011 000000100 100011011 100011011 ? 110000100 100000011 00...
result:
ok correct! (10000 test cases)
Test #80:
score: 0
Accepted
time: 1033ms
memory: 5376kb
input:
10000 9 0 111111111 111111111 110111111 111011111 111101111 111111111 111111111 111111101 111111111 0 111111101 111111111 111111111 111111111 111111111 111111111 111111111 111111101 111111111 0 111111111 101111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 1011...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100000010 100000000 000000000 000000000 000000000 100000000 100000000 000000010 100000000 ? 101110010 010000000 101110010 101110010 101110010 000001000 000000100 101110010 000000001 ? 100010010 010000000 10...
result:
ok correct! (10000 test cases)
Extra Test:
score: 0
Extra Test Passed