QOJ.ac
QOJ
ID | 题目 | 提交者 | 结果 | 用时 | 内存 | 语言 | 文件大小 | 提交时间 | 测评时间 |
---|---|---|---|---|---|---|---|---|---|
#328224 | #7788. Rook Detection | CharlieVinnie | AC ✓ | 1063ms | 10444kb | C++17 | 5.1kb | 2024-02-15 18:26:08 | 2024-02-15 18:26:09 |
Judging History
answer
#include "bits/stdc++.h"
#ifdef DEBUG
#include "PrettyDebug.hpp"
#else
#define debug(...) [](auto...){}(__VA_ARGS__)
#define debuga(...) [](auto...){}(__VA_ARGS__)
#endif
#define For(i,a,b) for(int i=a;i<=b;i++)
#define Rev(i,a,b) for(int i=a;i>=b;i--)
#define Fin(file) freopen(file,"r",stdin)
#define Fout(file) freopen(file,"w",stdout)
using namespace std; typedef long long ll; using Map = vector<vector<int>>;
// #define IDEBUG
#ifdef IDEBUG
mt19937 rng(190345);
class Interactor{
static constexpr int N=505;
int n,a[N][N];
public:
int start(){
// #define MANUAL
#ifdef MANUAL
cin>>n; For(i,1,n) { string s; cin>>s; For(j,1,n) a[i][j]=s[j-1]-'0'; }; return n;
#else
n=5; For(i,1,n) For(j,1,n) a[i][j]=0;
if(rng()&1) For(i,1,n) a[i][rng()%n+1]=1;
else For(i,1,n) a[rng()%n+1][i]=1;
return n;
#endif
}
Map query(Map mp){
cout<<"Query:\n";
For(i,1,n) { For(j,1,n) cout<<mp[i][j];; cout<<'\n'; }
Map ans(n+1,vector<int>(n+1,0));
For(i,1,n) For(j,1,n){
For(k,1,n) if(mp[i][j]==mp[k][j]&&a[k][j]) ans[i][j]=1;
For(k,1,n) if(mp[i][j]==mp[i][k]&&a[i][k]) ans[i][j]=1;
}
cout<<"Result:\n";
For(i,1,n) { For(j,1,n) cout<<ans[i][j];; cout<<'\n'; }
cout<<'\n';
return ans;
}
void answer(Map ans){
cout<<"Participant Answer:\n";
For(i,1,n) { For(j,1,n) cout<<ans[i][j];; cout<<'\n'; }
cout<<"Jury Answer:\n";
For(i,1,n) { For(j,1,n) cout<<a[i][j];; cout<<'\n'; }
int tt=0; For(i,1,n) For(j,1,n) if(ans[i][j]) { tt++; if(!a[i][j]) cout<<"Wrong Answer "<<i<<' '<<j<<'\n',exit(0); }
if(tt<n) cout<<"Wrong Answer: Not enough rooks\n",exit(0);
else cout<<"Accepted\n";
}
};
#else
class Interactor{
int n;
public:
int start() { cin>>n; return n; }
Map query(Map mp){
cout<<"?\n"; For(i,1,n) { For(j,1,n) cout<<mp[i][j];; cout<<'\n'; }
int result; cin>>result; if(result!=0) exit(0);
Map res(n+1,vector<int>(n+1)); For(i,1,n) { string s; cin>>s; For(j,1,n) res[i][j]=s[j-1]-'0'; }
return res;
}
void answer(Map ans){
cout<<"!\n"; For(i,1,n) { For(j,1,n) cout<<ans[i][j];; cout<<'\n'; }
int result; cin>>result; if(result!=0) exit(0);
}
};
#endif
Interactor O; int n; Map ans;
void calc(vector<int> A,vector<int> B){
vector<int> L(n+1),R(n+1),got(n+1); for(int o:A) L[o]=2,R[o]=n;
while(true){
int done=1; for(int o:A) if(L[o]==R[o]) ans[o][L[o]]=1; else { done=0; break; }
if(done) break;
vector<int> vis(n+1); Map mp(n+1,vector<int>(n+1));
for(int o:A) if(L[o]!=R[o]){
mp[o][1]=1; int mid=(L[o]+R[o])>>1; For(i,mid+1,R[o]) vis[i]=1,mp[o][i]=1;
}
for(int o:B) if(!vis[o]) got[o]=1,mp[o][o]=1;
Map res=O.query(mp);
for(int o:A) if(L[o]!=R[o]){
int mid=(L[o]+R[o])>>1; if(res[o][1]) L[o]=mid+1; else R[o]=mid;
}
for(int o:B) if(!vis[o]) (res[o][o]?ans[o][o]:ans[o][1])=1;
}
vector<int> tmp; for(int o:B) if(!got[o]) tmp.push_back(o);
if(tmp.size()){
Map mp(n+1,vector<int>(n+1)); for(int o:tmp) mp[o][o]=1;
Map res=O.query(mp); for(int o:tmp) (res[o][o]?ans[o][o]:ans[o][1])=1;
}
O.answer(ans);
}
void work(int qwq){
debug(qwq);
vector<int> L(n+1),R(n+1); For(o,1,n) L[o]=1,R[o]=n;
while(true){
int done=1; For(o,1,n) if(L[o]==R[o]) ans[L[o]][o]=1; else { done=0; break; }
if(done) break;
Map mp(n+1,vector<int>(n+1));
For(o,1,n) if(L[o]!=R[o]){
mp[qwq][o]=1; int mid=(L[o]+R[o])>>1; For(i,mid+1,R[o]) mp[i][o]=1;
}
Map res=O.query(mp);
For(o,1,n) if(L[o]!=R[o]){
int mid=(L[o]+R[o])>>1; if(res[qwq][o]) L[o]=mid+1; else R[o]=mid;
}
}
O.answer(ans);
}
void solve(){
n=O.start(); Map mp(n+1,vector<int>(n+1)); ans=mp;
For(i,2,n) mp[i][1]=mp[i][i]=1;
Map D=O.query(mp); mp=Map(n+1,vector<int>(n+1));
if(!D[1][1]) return work(1),void();
int zero=0; For(i,2,n) if(!D[i][i]) { zero=i; break; }
if(!zero){
For(i,1,n) mp[i][i]=1;
Map S=O.query(mp);
For(i,2,n) if(S[i][i]) ans[i][i]=1; else ans[i][1]=1;
if(S[1][1]) ans[1][1]=1,O.answer(ans); else calc({1},{});
}
else{
mp[1][1]=1; For(i,2,n) { mp[i][i]=1; if(D[i][i]) mp[i][1]=1; else if(i==zero) mp[1][i]=1; }
Map S=O.query(mp); For(i,2,n) if(!S[i][1]) return work(i),void();
vector<int> A,B; if(S[zero][zero]) ans[1][zero]=1; else if(S[1][zero]) ans[1][1]=1; else A.push_back(1);
For(i,2,n) if(D[i][i]) B.push_back(i); else A.push_back(i);
calc(A,B);
}
}
signed main(){
atexit([](){cerr<<"Time = "<<clock()<<" ms"<<endl;});
int T; cin>>T; while(T--) solve();
return 0;
}
// CONTINUE, NON-STOPPING, FOR CHARLIEY
// START TYPING IF YOU DON'T KNOW WHAT TO DO
// STOP TYPING IF YOU DON'T KNOW WHAT YOU'RE DOING
// Started Coding On: February 15 Thu, 16 : 32 : 01
这程序好像有点Bug,我给组数据试试?
详细
Test #1:
score: 100
Accepted
time: 1ms
memory: 3604kb
input:
1 3 0 111 101 111 0 111 111 101 0 111 111 111 0 111 111 110 0
output:
? 000 110 101 ? 110 010 101 ? 000 101 000 ? 000 000 001 ! 010 001 100
result:
ok correct! (1 test case)
Test #2:
score: 0
Accepted
time: 74ms
memory: 3680kb
input:
9898 3 0 111 110 111 0 111 111 111 0 3 0 111 111 111 0 011 101 111 0 111 111 111 0 3 0 111 111 111 0 011 111 111 0 111 111 111 0 3 0 111 101 111 0 101 101 111 0 111 111 111 0 111 111 110 0 3 0 111 111 010 0 111 110 111 0 111 111 010 0 3 0 111 111 111 0 011 111 110 0 010 111 111 0 3 0 111 111 111 0 1...
output:
? 000 110 101 ? 100 010 001 ! 100 010 001 ? 000 110 101 ? 100 010 001 ? 101 000 000 ! 001 100 001 ? 000 110 101 ? 100 010 001 ? 101 000 000 ! 001 010 001 ? 000 110 101 ? 110 010 101 ? 101 101 000 ? 000 000 001 ! 001 001 100 ? 000 110 101 ? 101 110 001 ? 000 010 101 ! 001 010 010 ? 000 110 101 ? 100 ...
result:
ok correct! (9898 test cases)
Test #3:
score: 0
Accepted
time: 97ms
memory: 3560kb
input:
10000 4 0 1111 1011 1111 1111 0 1111 1111 1111 1111 0 1111 1111 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 0110 1111 1111 0 1111 1111 1111 1111 0 4 0 1111 1011 1111...
output:
? 0000 1100 1010 1001 ? 1100 0100 1010 1001 ? 0000 1001 0010 0000 ? 0000 0000 0000 0001 ! 0100 0001 0010 0001 ? 0000 1100 1010 1001 ? 1001 1100 1010 0001 ? 0000 0100 0010 1001 ? 0000 0100 0000 1010 ! 0001 0100 1000 0100 ? 0000 1100 1010 1001 ? 1100 0100 1010 1001 ? 0000 1001 0010 0000 ? 0000 1010 00...
result:
ok correct! (10000 test cases)
Test #4:
score: 0
Accepted
time: 101ms
memory: 3740kb
input:
10000 4 0 1111 1111 1111 1111 0 0111 1111 1111 1111 0 1111 1111 1111 1111 0 4 0 1111 1011 1111 1111 0 1111 1011 1111 1111 0 1111 0110 1111 1111 0 1111 1111 1111 1110 0 4 0 1111 1111 1111 1111 0 0111 1011 1101 1111 0 1111 1111 1111 1111 0 4 0 1111 1111 1111 1111 0 0111 1111 1111 1110 0 0110 1111 1111...
output:
? 0000 1100 1010 1001 ? 1000 0100 0010 0001 ? 1001 0000 0000 0000 ! 0001 0100 0010 0001 ? 0000 1100 1010 1001 ? 1100 0100 1010 1001 ? 0000 1001 0010 0000 ? 0000 1010 0000 0001 ! 1000 0010 0010 1000 ? 0000 1100 1010 1001 ? 1000 0100 0010 0001 ? 1001 0000 0000 0000 ! 0001 1000 1000 0001 ? 0000 1100 10...
result:
ok correct! (10000 test cases)
Test #5:
score: 0
Accepted
time: 92ms
memory: 3876kb
input:
10000 4 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 1111 1111 0 1111 1111 1111 1110 0 4 0 1111 1111 1111 1101 0 1111 1011 1111 1110 0 4 0 1111 1101 1011 1001 0 0111 1111 1111 1111 0 1111 1111 1111 1111 0 4 0 1111 1111 1111 1111 0 0111 1111 ...
output:
? 0000 1100 1010 1001 ? 1000 0100 0010 0001 ! 1000 1000 0010 0001 ? 0000 1100 1010 1001 ? 1010 1100 0010 1001 ? 0000 0100 1001 0000 ? 0000 0000 0000 0001 ! 0010 1000 0001 1000 ? 0000 1100 1010 1001 ? 1000 0100 0010 0001 ! 1000 1000 0010 1000 ? 0000 1100 1010 1001 ? 1000 0100 0010 0001 ? 1001 0000 00...
result:
ok correct! (10000 test cases)
Test #6:
score: 0
Accepted
time: 136ms
memory: 3732kb
input:
10000 4 0 1111 1111 1111 1111 0 0111 1111 1101 1111 0 0110 1111 1111 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 1110 1110 1111 0 1111 1111 1111 0110 0 1111 1111 1111 1111 0 4 0 1111 1111 1111...
output:
? 0000 1100 1010 1001 ? 1000 0100 0010 0001 ? 1001 0000 0000 0000 ? 1010 0000 0000 0000 ! 0010 0100 1000 0001 ? 0000 1100 1010 1001 ? 1001 1100 1010 0001 ? 0000 0100 0010 1001 ? 0000 0100 0000 1010 ! 0001 1000 0010 0010 ? 0000 1100 1010 1001 ? 1001 1100 1010 0001 ? 0000 0100 0010 1001 ? 0000 0100 00...
result:
ok correct! (10000 test cases)
Test #7:
score: 0
Accepted
time: 729ms
memory: 10444kb
input:
7368 4 0 1111 1111 1111 1111 0 0111 1111 1111 1111 0 1111 1111 1111 1111 0 4 0 1111 1111 1111 1111 0 0111 1011 1111 1111 0 0110 1111 1111 1111 0 0101 1111 1111 1111 0 4 0 1111 1111 1111 1111 0 0111 1111 1111 1111 0 1111 1111 1111 1111 0 4 0 1111 1111 1111 1110 0 1111 1111 1111 1111 0 1111 1111 1111 ...
output:
? 0000 1100 1010 1001 ? 1000 0100 0010 0001 ? 1001 0000 0000 0000 ! 0001 0100 0010 0001 ? 0000 1100 1010 1001 ? 1000 0100 0010 0001 ? 1001 0000 0000 0000 ? 1010 0000 0000 0000 ! 0100 1000 0010 0001 ? 0000 1100 1010 1001 ? 1000 0100 0010 0001 ? 1001 0000 0000 0000 ! 0001 0100 0010 0001 ? 0000 1100 10...
result:
ok correct! (7368 test cases)
Test #8:
score: 0
Accepted
time: 666ms
memory: 10068kb
input:
10000 9 0 111111111 101111111 110111111 111111111 111101111 111110111 111111111 111111111 111111111 0 111111110 111111111 110111111 111111111 111101111 111110111 111111111 111111111 111111111 0 111111111 011110110 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 110000000 010000000 001000000 100100000 000010000 000001000 100000100 100000010 100000001 ? 000000000 100001111 100001111 000100000 100001111 100001111 000000000 000000000 000000000 ? 000000000 100110000 10...
result:
ok correct! (10000 test cases)
Test #9:
score: 0
Accepted
time: 604ms
memory: 9340kb
input:
10000 5 0 11111 10111 11111 11111 11111 0 11111 10111 11111 11111 11111 0 11111 11111 11011 11111 11111 0 11111 01110 11011 11111 11111 0 11111 11111 11111 11111 11110 0 8 0 11111111 10111111 11111111 11111111 11110111 11111011 11111111 11111111 0 11111111 10111111 11111111 11111111 11110111 1111101...
output:
? 00000 11000 10100 10010 10001 ? 11000 01000 10100 10010 10001 ? 00000 10011 00100 00000 00000 ? 00000 10001 00100 00010 00000 ? 00000 00000 00000 00000 00001 ! 10000 00010 10000 00010 10000 ? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11000000 01000000 10100000 10010...
result:
ok correct! (10000 test cases)
Test #10:
score: 0
Accepted
time: 619ms
memory: 9664kb
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 ? 100100000 110000000 101000000 000100000 000010000 100001000 100000100 100000010 100000001 ? 000000000 010000000 001000000 100001111 100001111 000000000 000000000 000000000 000000000 ? 000000000 010000000 00...
result:
ok correct! (10000 test cases)
Test #11:
score: 0
Accepted
time: 679ms
memory: 10412kb
input:
10000 4 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 6 0 111111 111111 111111 111111 111101 111111 0 111111 111111 111111 111111 111111 111111 0 111111 111111 111111 111111 011100 111111 0 111111 111111 1111...
output:
? 0000 1100 1010 1001 ? 1000 0100 0010 0001 ! 1000 1000 0010 0001 ? 000000 110000 101000 100100 100010 100001 ? 100000 010000 001000 000100 000010 000001 ! 100000 010000 001000 000100 000010 000001 ? 000000 110000 101000 100100 100010 100001 ? 100010 110000 101000 100100 000010 100001 ? 000000 01000...
result:
ok correct! (10000 test cases)
Test #12:
score: 0
Accepted
time: 310ms
memory: 8824kb
input:
10000 6 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 111111111 111111111 111111111 0 6 0 111111 111...
output:
? 000000 110000 101000 100100 100010 100001 ? 100000 010000 001000 000100 000010 000001 ! 100000 010000 001000 000100 000010 000001 ? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100000000 010000000 001000000 000100000 000010000 000001000 000000100 0000...
result:
ok correct! (10000 test cases)
Test #13:
score: 0
Accepted
time: 497ms
memory: 8940kb
input:
10000 6 0 111111 101111 110111 111011 100010 111110 0 110010 101111 110111 111011 100010 111110 0 111111 100011 100011 100011 111111 100011 0 111111 011110 011110 011110 111101 011110 0 8 0 11111111 11000110 10100110 11101111 10001110 11111011 10000110 11111110 0 11101111 11000110 10100110 11101111 ...
output:
? 000000 110000 101000 100100 100010 100001 ? 110000 010000 001000 000100 100010 000001 ? 000000 100011 100011 100011 000000 100011 ? 000000 100001 100001 100001 000010 100001 ! 100000 000010 000010 000010 100000 000010 ? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 1001...
result:
ok correct! (10000 test cases)
Test #14:
score: 0
Accepted
time: 429ms
memory: 7676kb
input:
10000 6 0 111111 001111 010111 011011 011101 011110 0 111111 011111 110111 001011 001101 001110 0 111111 000000 111111 000000 000000 000000 0 111111 000101 111111 111010 111010 111010 0 111111 000101 111111 111111 111111 111111 0 9 0 011101111 101101111 110101111 111001111 111111111 111100111 111101...
output:
? 000000 110000 101000 100100 100010 100001 ? 110000 010000 001000 000100 000010 000001 ? 000000 111111 000000 111111 111111 111111 ? 000000 111111 111111 000000 000000 000000 ? 000000 111010 000000 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: 515ms
memory: 8376kb
input:
10000 9 0 111111111 111111111 111111111 111111111 111111111 111110111 111111011 111111111 111111110 0 111111111 111111111 111111111 111111111 111111111 111110111 011111011 111111111 011111110 0 111111111 111111111 111111111 111111111 111111111 111111111 110111011 111111111 110111011 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100001000 110000000 101000000 100100000 100010000 000001000 000000100 100000010 000000001 ? 000000000 000000000 000000000 000000000 000000000 111111111 111111111 111111111 111111111 ? 000000000 000000000 00...
result:
ok correct! (10000 test cases)
Test #16:
score: 0
Accepted
time: 384ms
memory: 7928kb
input:
10000 7 0 1111111 1111111 1010000 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 0111011 1111111 1111111 0 1111111 1111111 1111111 1111111 1111111 1111111 111111...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1000000 0100000 0010000 0001000 0000100 0000010 0000001 ! 1000000 1000000 0010000 1000000 1000000 1000000 1000000 ? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1100000 0100000 1010000 1001000 0000100 1000010 1000001 ? 0000000 ...
result:
ok correct! (10000 test cases)
Test #17:
score: 0
Accepted
time: 515ms
memory: 8556kb
input:
10000 9 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 111111111 111111111 111011111 111111111 111111111 111111111 111111111 111111110 0 8 0 11111111 10111111 11011111 11101111 11110111 11111111 11111111 11111110 0 11111111 01111111 01011111 0...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100000000 010000000 001000000 000100000 000010000 000001000 000000100 000000010 000000001 ! 100000000 010000000 001000000 100000000 000010000 000001000 000000100 000000010 100000000 ? 00000000 11000000 1010...
result:
ok correct! (10000 test cases)
Test #18:
score: 0
Accepted
time: 894ms
memory: 10316kb
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: 887ms
memory: 10256kb
input:
10000 8 0 11111111 10111111 11011111 11101111 11111111 10110111 11111101 11111111 0 11110111 10111111 11011111 11101111 11111111 10110111 11111101 11111111 0 11111111 11111111 10110111 01111101 11110111 11111111 01111101 11111111 0 11111111 01111111 10110111 01100111 11111111 11111111 01100111 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11000000 01000000 00100000 00010000 10001000 10000100 00000010 10000001 ? 00000000 10000111 10000111 10000111 00001000 00000000 10000111 00000000 ? 00000000 10000001 10000001 10011000 00000000 00000100 10011000 00000000 ? 00...
result:
ok correct! (10000 test cases)
Test #20:
score: 0
Accepted
time: 867ms
memory: 10348kb
input:
10000 7 0 1111111 0011111 0101111 0110111 0111011 0111101 0111110 0 0011111 1011111 1101111 1110111 1111011 1111101 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 ? 1100000 0100000 0010000 0001000 0000100 0000010 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: 793ms
memory: 10292kb
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: 801ms
memory: 10444kb
input:
10000 9 0 111111111 111111111 111111111 100101000 111111111 100001000 111111111 111111111 111111111 0 111111111 101111111 110111111 111011111 111101111 111111111 111111011 111111101 111111110 0 7 0 1111111 0011111 1111111 1111111 0111011 0111101 1111111 0 0011111 1011111 1111111 1111111 1111011 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100000000 010000000 001000000 000100000 000010000 000001000 000000100 000000010 000000001 ! 100000000 100000000 100000000 100000000 100000000 000001000 100000000 100000000 100000000 ? 0000000 1100000 101000...
result:
ok correct! (10000 test cases)
Test #23:
score: 0
Accepted
time: 623ms
memory: 10272kb
input:
10000 6 0 111111 111111 111111 111011 111101 111110 0 111111 111111 111111 011111 011101 011110 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 ? 100100 110000 101000 000100 000010 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: 331ms
memory: 5484kb
input:
10000 5 0 11111 00111 01011 01101 01110 0 11111 10111 11011 11101 11110 0 11111 01111 01111 11111 11111 0 11111 11110 01111 11011 01111 0 5 0 11111 10111 11011 11101 11111 0 10111 10111 11011 11101 11111 0 11111 01111 01111 11111 11111 0 01111 11110 01111 11011 11111 0 11111 11111 11111 11111 11110 ...
output:
? 00000 11000 10100 10010 10001 ? 11000 01000 00100 00010 00001 ? 00000 10011 10011 10011 10011 ? 00000 10100 10100 10001 10001 ! 10000 00100 01000 00001 00010 ? 00000 11000 10100 10010 10001 ? 11000 01000 00100 00010 10001 ? 10011 10011 10011 10011 00000 ? 10001 10100 10100 10001 00000 ? 00000 0000...
result:
ok correct! (10000 test cases)
Test #25:
score: 0
Accepted
time: 393ms
memory: 5560kb
input:
10000 6 0 111111 101111 110111 111111 111011 111110 0 101111 101111 110111 111111 111011 111110 0 011111 111011 111011 111100 111111 011111 0 011011 011111 111111 111111 111101 011011 0 111011 111111 111111 110111 111101 011111 0 6 0 111111 111111 110111 111011 111101 111110 0 111111 110111 111111 1...
output:
? 000000 110000 101000 100100 100010 100001 ? 110000 010000 001000 100100 100010 000001 ? 100011 100011 100011 000100 000000 100011 ? 100100 100001 100001 000000 000010 100100 ? 101000 000000 000000 000100 000010 101000 ! 001000 000010 000001 000100 100000 010000 ? 000000 110000 101000 100100 100010...
result:
ok correct! (10000 test cases)
Test #26:
score: 0
Accepted
time: 441ms
memory: 5424kb
input:
10000 7 0 1111111 1111111 1101111 1110111 1111011 1111101 1011111 0 1101111 1111111 1101111 1110111 1111011 1111101 1011111 0 1011111 1111000 1011111 0111111 0111111 1011111 1111111 0 0111111 1110110 0111111 0111111 1011110 1010111 1111111 0 0111111 1101101 1001111 1011101 1111111 1111111 1111110 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1010000 1100000 0010000 0001000 0000100 0000010 1000001 ? 1000111 0100000 1000111 1000111 1000111 1000111 0000000 ? 1000001 0100000 1000001 1001000 1001000 1000001 0000000 ? 1000010 0100000 1000010 1010000 0000000 0000000 0000001 ! 0000100 ...
result:
ok correct! (10000 test cases)
Test #27:
score: 0
Accepted
time: 961ms
memory: 10260kb
input:
10000 8 0 11111111 00111111 01011111 01101111 01110111 01111011 01111101 01111110 0 11111111 10111111 11011111 11101111 11110111 11111011 11111101 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 ? 11000000 01000000 00100000 00010000 00001000 00000100 00000010 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: 942ms
memory: 10248kb
input:
10000 8 0 11111111 10111111 11011111 11110100 11111100 11111011 11110110 11110101 0 10111111 10111111 11011111 11110100 11111100 11111011 11110110 11110101 0 01111100 11110111 01111100 11101111 11111011 01111100 11111111 11111111 0 01110111 01111110 01110111 11111111 11111111 11111101 11101111 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11000000 01000000 00100000 10010000 10001000 00000100 10000010 10000001 ? 10000111 10000111 10000111 00010000 00001000 10000111 00000000 00000000 ? 10011000 10000001 10011000 00000000 00000000 10011000 00000010 00000000 ? 10...
result:
ok correct! (10000 test cases)
Test #29:
score: 0
Accepted
time: 964ms
memory: 10248kb
input:
10000 8 0 11111111 10111111 11011111 11111011 11110111 11111111 11111101 11111110 0 10111111 10111111 11011111 11111011 11110111 11111111 11111101 11111110 0 01111011 01111011 01111011 11101111 11111111 11111111 11111111 01111011 0 11111010 11111010 01111111 11111111 01111111 11100110 11100011 01111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11000000 01000000 00100000 10010000 00001000 10000100 00000010 00000001 ? 10000111 10000111 10000111 00010000 10000111 00000000 10000111 10000111 ? 10011000 10011000 10011000 00000000 10000001 00000100 10000001 10011000 ? 10...
result:
ok correct! (10000 test cases)
Test #30:
score: 0
Accepted
time: 954ms
memory: 10332kb
input:
10000 8 0 11111111 10111111 11101101 11011101 11110111 11001101 11001111 11111110 0 10111111 10111111 11101101 11011101 11110111 11001101 11001111 11111110 0 11001111 01111101 11101010 11011010 01111101 11111111 11111111 11001111 0 11010101 11011100 11110100 11111111 01101111 11111011 11010110 01111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11000000 01000000 10100000 10010000 00001000 10000100 10000010 00000001 ? 10000111 10000111 00100000 00010000 10000111 00000000 00000000 10000111 ? 10000001 10011000 00100000 00000000 10011000 00000100 00000010 10000001 ? 00...
result:
ok correct! (10000 test cases)
Test #31:
score: 0
Accepted
time: 886ms
memory: 10252kb
input:
10000 8 0 11111111 00111111 01011111 01101111 01110111 01111011 01111101 01111110 0 11111111 10111111 11011111 11101111 11110111 11111011 11111101 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 ? 11000000 01000000 00100000 00010000 00001000 00000100 00000010 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: 973ms
memory: 10328kb
input:
10000 9 0 111111111 101111111 110111111 111011111 111111111 111110111 111111011 111111101 111111110 0 111111111 111111111 110111111 111011111 101111111 111110111 111111011 111111101 111111110 0 111111111 111111111 111111111 011111111 111101111 111111111 011111111 011111111 111111111 0 111111111 0111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 110000000 010000000 001000000 000100000 100010000 000001000 000000100 000000010 000000001 ? 000000000 100001111 100001111 100001111 000010000 100001111 100001111 100001111 100001111 ? 000000000 100000011 10...
result:
ok correct! (10000 test cases)
Test #33:
score: 0
Accepted
time: 975ms
memory: 10240kb
input:
10000 9 0 111111111 111111111 010111111 011011111 011101111 011110111 011111011 011111101 011111110 0 101111111 111111111 110111111 111011111 111101111 111110111 111111011 111111101 111111110 0 111111111 111110000 011111111 101111111 101111111 011111111 101111111 101111111 011111111 0 111111111 1110...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 101000000 110000000 001000000 000100000 000010000 000001000 000000100 000000010 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: 1008ms
memory: 10260kb
input:
10000 9 0 111111111 101111111 110111111 111011111 111111111 111110111 111111011 111111101 111111110 0 101111111 101111111 110111111 111011111 111111111 111110111 111111011 111111101 111111110 0 011111111 111111111 011111111 011111111 111101111 111111111 111111111 011111111 111111111 0 111111100 0111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 110000000 010000000 001000000 000100000 100010000 000001000 000000100 000000010 000000001 ? 100001111 100001111 100001111 100001111 000010000 100001111 100001111 100001111 100001111 ? 100110000 100000011 10...
result:
ok correct! (10000 test cases)
Test #35:
score: 0
Accepted
time: 1031ms
memory: 10320kb
input:
10000 9 0 111111111 101111111 110111111 111011111 111101111 111110111 111111111 111111101 111111110 0 111111111 111111111 110111111 111011111 111101111 111110111 101111111 111111101 111111110 0 111111111 111111111 011111111 111111111 011111111 011111111 111111111 111111111 111111111 0 111111111 1110...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 110000000 010000000 001000000 000100000 000010000 000001000 100000100 000000010 000000001 ? 000000000 100001111 100001111 100001111 100001111 100001111 000000000 100001111 100001111 ? 000000000 100000011 10...
result:
ok correct! (10000 test cases)
Test #36:
score: 0
Accepted
time: 1037ms
memory: 10248kb
input:
10000 9 0 111111111 111111011 110111111 111011111 111101111 111110111 111111111 111111101 111111110 0 110111111 111111011 110111111 111011111 111101111 111110111 111111111 111111101 111111110 0 011111011 101111111 111111111 111111111 011111011 111111111 111111111 011111011 011111011 0 111111000 1011...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 101000000 110000000 001000000 000100000 000010000 000001000 100000100 000000010 000000001 ? 100001111 010000000 100001111 100001111 100001111 100001111 000000000 100001111 100001111 ? 100110000 010000000 10...
result:
ok correct! (10000 test cases)
Test #37:
score: 0
Accepted
time: 475ms
memory: 5620kb
input:
10000 7 0 1111111 1011111 1111111 1110111 1111011 1111101 1111110 0 1011111 0011111 1111111 1110111 1111011 1111101 1111110 0 1111111 0111010 1111111 1111111 1111111 1111111 1111111 0 1111111 1010011 1111111 1111111 1111111 1111111 0111110 0 1111111 0110011 1111111 1111111 1111111 1111111 1111111 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1100000 0100000 1010000 0001000 0000100 0000010 0000001 ? 0000000 1111111 0000000 0000000 1111111 1111111 1111111 ? 0000000 1111111 1000101 1000101 0000000 0000000 0111010 ? 0000000 1101101 0000000 1000001 0000000 0101000 0000000 ! 0000100 ...
result:
ok correct! (10000 test cases)
Test #38:
score: 0
Accepted
time: 490ms
memory: 5428kb
input:
10000 8 0 11111111 10111111 11111111 11111111 11110111 11111011 11111101 11111110 0 11111111 11111111 11111111 10111111 11110111 11111011 11111101 11111110 0 11111111 01111111 11011111 11111000 11111111 11111111 01111111 11111111 0 11111111 11111111 11011111 11111111 01111111 11111111 01110111 01111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11000000 01000000 10100000 10010000 00001000 00000100 00000010 00000001 ? 00000000 10000111 00100000 00010000 10000111 10000111 10000111 10000111 ? 00000000 10011000 00100000 00000000 10000001 10000001 10011000 10000001 ? 00...
result:
ok correct! (10000 test cases)
Test #39:
score: 0
Accepted
time: 475ms
memory: 5176kb
input:
10000 8 0 11111111 10111111 11011111 11101111 11110111 11111011 11111111 11111110 0 11111111 10111111 11011111 11101111 11110111 11111011 11111111 11111110 0 11111111 01111101 01111101 11111111 11111111 01111101 11111111 01111101 0 11111111 11111111 11111111 01111111 11100111 01111111 11111101 01111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11000000 01000000 00100000 00010000 00001000 00000100 10000010 00000001 ? 00000000 10000111 10000111 10000111 10000111 10000111 00000000 10000111 ? 00000000 10011000 10011000 10000001 10000001 10011000 00000010 10011000 ? 00...
result:
ok correct! (10000 test cases)
Test #40:
score: 0
Accepted
time: 503ms
memory: 5312kb
input:
10000 8 0 11111111 10111111 11011111 11101111 11110111 11111111 11111101 11111101 0 10111111 10111111 11011111 11101111 11110111 11111111 11111101 11111101 0 01111101 01111101 01111101 11111111 01111101 11111111 11111111 11111111 0 01111111 11111101 11111101 01111111 01111111 11111111 11111101 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11000000 01000000 00100000 00010000 00001000 10000100 00000010 10000001 ? 10000111 10000111 10000111 10000111 10000111 00000000 10000111 00000000 ? 10011000 10011000 10011000 10000001 10011000 00000100 10000001 00000000 ? 10...
result:
ok correct! (10000 test cases)
Test #41:
score: 0
Accepted
time: 967ms
memory: 10320kb
input:
10000 9 0 111111111 111110111 010111111 011011111 111111111 111111111 011111011 011111101 011111110 0 111110111 111110111 110111111 111011111 111111111 111111111 111111011 111111101 111111110 0 111111111 111111000 111111111 111111111 111111111 111111111 111111111 011110111 111111111 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 101000000 110000000 001000000 000100000 100010000 100001000 000000100 000000010 000000001 ? 000000000 010000000 100001111 100001111 000010000 000000000 100001111 100001111 100001111 ? 000000000 010000000 10...
result:
ok correct! (10000 test cases)
Test #42:
score: 0
Accepted
time: 942ms
memory: 10312kb
input:
10000 9 0 111111111 110111101 101111101 100111101 111101111 100111101 111111011 111111101 111111111 0 111101111 110111101 101111101 100111101 111101111 100111101 111111011 111111101 111111111 0 100111111 110110001 101110001 100110001 100111111 111111111 011111101 100111111 111111111 0 100111111 1101...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100010000 110000000 101000000 100100000 000010000 100001000 000000100 000000010 100000001 ? 100001111 010000000 001000000 000100000 100001111 000000000 100001111 100001111 000000000 ? 100000011 010000000 00...
result:
ok correct! (10000 test cases)
Test #43:
score: 0
Accepted
time: 970ms
memory: 10444kb
input:
10000 9 0 111111111 101111111 111111111 111011111 111101111 111110111 111111111 111111101 111111110 0 101111111 101111111 111111111 111011111 111101111 111110111 111111111 111111101 111111110 0 111111111 011111111 111111111 111111111 111111111 011111111 111111111 011111111 111111111 0 011111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 110000000 010000000 101000000 000100000 000010000 000001000 100000100 000000010 000000001 ? 100001111 100001111 001000000 100001111 100001111 100001111 000000000 100001111 100001111 ? 100000011 100110000 00...
result:
ok correct! (10000 test cases)
Test #44:
score: 0
Accepted
time: 390ms
memory: 5460kb
input:
10000 7 0 1111111 1111111 1101111 1110111 1111011 1111111 1111110 0 1101111 1111111 1101111 1110111 1111011 1111111 1111110 0 0111111 1111111 1111111 1111111 1111111 1111111 1111111 0 1111111 1111111 0111111 1111111 0111111 1111101 0111111 0 1111111 1111111 1111111 1111111 1111111 1111111 1111111 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1010000 1100000 0010000 0001000 0000100 1000010 0000001 ? 1000111 0100000 1000111 1000111 1000111 0000000 1000111 ? 1001000 0100000 1000001 1000001 1000001 0000010 1000001 ? 0000000 0100000 1000010 0000000 1000010 0000000 1000010 ! 0001000 ...
result:
ok correct! (10000 test cases)
Test #45:
score: 0
Accepted
time: 455ms
memory: 5032kb
input:
10000 8 0 11111111 11111111 11011111 11101111 11111111 11111011 11111101 11111110 0 11011111 11111111 11011111 11101111 11111111 11111011 11111101 11111110 0 11111111 10111111 11111111 01111101 11110111 01111101 11111111 01111101 0 01111111 10111111 11110111 11111110 11111111 01101111 01111111 01101...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10100000 11000000 00100000 00010000 10001000 00000100 00000010 00000001 ? 10000111 01000000 10000111 10000111 00001000 10000111 10000111 10000111 ? 10000001 01000000 10000001 10011000 00000000 10011000 10000001 10011000 ? 10...
result:
ok correct! (10000 test cases)
Test #46:
score: 0
Accepted
time: 415ms
memory: 5416kb
input:
10000 8 0 11111111 00111111 11111111 01101111 11111111 01111011 01111101 11111111 0 11111111 10111111 11111111 11101111 11111111 11111011 11111101 11111111 0 11111111 01111101 11111111 11111111 11111111 01111101 01111101 11111111 0 11111111 01111111 11111111 11111111 11111111 11111111 11111111 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11000000 01000000 10100000 00010000 10001000 00000100 00000010 10000001 ? 00000000 10000111 00100000 10000111 00001000 10000111 10000111 00000000 ? 00000000 10011000 00100000 10000001 00000000 10011000 10011000 00000000 ? 00...
result:
ok correct! (10000 test cases)
Test #47:
score: 0
Accepted
time: 479ms
memory: 5164kb
input:
10000 8 0 11111111 10111111 11011111 11111111 11110111 11111011 11111101 11111110 0 10111111 10111111 11011111 11111111 11110111 11111011 11111101 11111110 0 11111111 11111111 11111111 11101111 11111111 01111111 11111111 11111111 0 01111111 01111111 01111111 11111111 01111111 11111110 11111111 01111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11000000 01000000 00100000 10010000 00001000 00000100 00000010 00000001 ? 10000111 10000111 10000111 00010000 10000111 10000111 10000111 10000111 ? 10000001 10000001 10000001 00000000 10000001 10011000 10000001 10000001 ? 10...
result:
ok correct! (10000 test cases)
Test #48:
score: 0
Accepted
time: 929ms
memory: 10392kb
input:
10000 9 0 111111111 101111111 110111111 111011111 111101111 111110111 111111111 111111101 111111111 0 101111111 101111111 110111111 111011111 111101111 111110111 111111111 111111101 111111111 0 111111111 111111111 111111111 011111111 111111111 011111111 111111111 111111111 111111111 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 110000000 010000000 001000000 000100000 000010000 000001000 100000100 000000010 100000001 ? 100001111 100001111 100001111 100001111 100001111 100001111 000000000 100001111 000000000 ? 100000011 100000011 10...
result:
ok correct! (10000 test cases)
Test #49:
score: 0
Accepted
time: 926ms
memory: 10340kb
input:
10000 9 0 111111111 111111111 111111111 111111111 111101111 111110111 111111011 111111111 111111111 0 111101111 111111111 111111111 111111111 111101111 111110111 111111011 111111111 111111111 0 111111111 111111111 111111111 111011111 011111100 011111100 111111111 111111111 111111111 0 011111100 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100010000 110000000 101000000 100100000 000010000 000001000 000000100 100000010 100000001 ? 100001111 010000000 001000000 000100000 100001111 100001111 100001111 000000000 000000000 ? 100000011 010000000 00...
result:
ok correct! (10000 test cases)
Test #50:
score: 0
Accepted
time: 977ms
memory: 10328kb
input:
10000 9 0 111111111 111111111 110111111 111111111 111111111 111110111 111111011 111111101 111111111 0 110111111 111111111 110111111 111111111 111111111 111110111 111111011 111111101 111111111 0 111111111 111111111 111111111 111111111 111101111 011110111 011110111 111111111 111111111 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 101000000 110000000 001000000 100100000 100010000 000001000 000000100 000000010 100000001 ? 100001111 010000000 100001111 000100000 000010000 100001111 100001111 100001111 000000000 ? 100000011 010000000 10...
result:
ok correct! (10000 test cases)
Test #51:
score: 0
Accepted
time: 245ms
memory: 4868kb
input:
10000 7 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 1111111 0 1111111 1111111 1111111 1111111 1111111 1111111 111111...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1000000 0100000 0010000 0001000 0000100 0000010 0000001 ! 1000000 0100000 0010000 0001000 1000000 0000010 0000001 ? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1000100 1100000 1010000 1001000 0000100 1000010 1000001 ? 0000000 ...
result:
ok correct! (10000 test cases)
Test #52:
score: 0
Accepted
time: 332ms
memory: 5028kb
input:
10000 8 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 0 01111111 11111111 11111111 11111111 11111111 11111111 11111111 11111110 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 ? 10000000 01000000 00100000 00010000 00001000 00000100 00000010 00000001 ? 10000111 00000000 00000000 00000000 00000000 00000000 00000000 00000000 ? 10000001 00000000 00000000 00000000 00000000 00000000 00000000 00000000 ? 10...
result:
ok correct! (10000 test cases)
Test #53:
score: 0
Accepted
time: 313ms
memory: 5316kb
input:
10000 8 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 11111110 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 0...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10000000 01000000 00100000 00010000 00001000 00000100 00000010 00000001 ! 10000000 10000000 10000000 00010000 00001000 00000100 00000010 00000001 ? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10...
result:
ok correct! (10000 test cases)
Test #54:
score: 0
Accepted
time: 430ms
memory: 5096kb
input:
10000 8 0 11111111 10111111 11111111 11101111 11111111 11111111 11111111 11111111 0 11111111 11111111 11111111 11101111 11111111 11111111 11111111 11111111 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11000000 01000000 10100000 00010000 10001000 10000100 10000010 10000001 ? 00000000 10000111 00100000 10000111 00001000 00000000 00000000 00000000 ? 00000000 10000001 00100000 10000001 00001000 00000100 00000010 00000000 ? 00...
result:
ok correct! (10000 test cases)
Test #55:
score: 0
Accepted
time: 284ms
memory: 5096kb
input:
10000 8 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 11111111 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 1...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10000000 01000000 00100000 00010000 00001000 00000100 00000010 00000001 ! 10000000 10000000 00100000 00010000 00001000 00000100 00000010 00000001 ? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10...
result:
ok correct! (10000 test cases)
Test #56:
score: 0
Accepted
time: 941ms
memory: 10320kb
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 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100100000 110000000 101000000 000100000 100010000 100001000 100000100 100000010 100000001 ? 000000000 010000000 001000000 100001111 000010000 000000000 000000000 000000000 000000000 ? 000000000 010000000 00...
result:
ok correct! (10000 test cases)
Test #57:
score: 0
Accepted
time: 862ms
memory: 10392kb
input:
10000 9 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 101111111 111111111 111111111 111111111 111111111 111111111 111111111 111111110 0 9 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 ...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100000000 010000000 001000000 000100000 000010000 000001000 000000100 000000010 000000001 ! 100000000 100000000 001000000 000100000 000010000 000001000 000000100 000000010 100000000 ? 000000000 110000000 10...
result:
ok correct! (10000 test cases)
Test #58:
score: 0
Accepted
time: 638ms
memory: 10288kb
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 110000000 101000000 100100000 100010000 000001000 100000100 100000010 100000001 ? 000000000 010000000 001000000 000100000 000010000 100001111 000000000 000000000 000000000 ? 000000000 010000000 00...
result:
ok correct! (10000 test cases)
Test #59:
score: 0
Accepted
time: 673ms
memory: 10404kb
input:
10000 9 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 9 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 ...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100000000 010000000 001000000 000100000 000010000 000001000 000000100 000000010 000000001 ! 100000000 010000000 001000000 000100000 000010000 000001000 000000100 000000010 000000001 ? 000000000 110000000 10...
result:
ok correct! (10000 test cases)
Test #60:
score: 0
Accepted
time: 845ms
memory: 10300kb
input:
10000 7 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 1111111 0 1111111 1111111 1101111 1111111 1111111 1111111 111111...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1000000 0100000 0010000 0001000 0000100 0000010 0000001 ! 1000000 0100000 0010000 0001000 1000000 0000010 0000001 ? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1000100 1100000 1010000 1001000 0000100 1000010 1000001 ? 0000000 ...
result:
ok correct! (10000 test cases)
Test #61:
score: 0
Accepted
time: 879ms
memory: 10332kb
input:
10000 7 0 1111111 1011111 1111110 1110111 1111111 1111111 1111111 0 1111110 1111111 1111110 1110111 1111111 1111111 1111111 0 1111111 1111111 1101111 1111111 1111111 1111111 1111111 0 1111111 0111110 1101111 0111110 1111011 1111111 1111111 0 1111111 0111111 1101111 1111111 1111011 1111111 1111111 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1100000 0100000 1010000 0001000 1000100 1000010 1000001 ? 0000000 1000111 0010000 1000111 0000000 0000000 0000000 ? 0000000 1000001 0010000 1000001 0000100 0000010 0000000 ? 0000000 1000010 0010000 1000010 0000100 0000000 0000001 ! 0100000 ...
result:
ok correct! (10000 test cases)
Test #62:
score: 0
Accepted
time: 806ms
memory: 10328kb
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 111111111 111111111 111111111 111111111 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 110000000 010000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 000000000 100001111 001000000 000100000 000010000 000000000 000000000 000000000 000000000 ? 000000000 100000011 00...
result:
ok correct! (10000 test cases)
Test #63:
score: 0
Accepted
time: 513ms
memory: 8328kb
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 01111110 11111111 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10000100 11000000 10100000 10010000 10001000 00000100 10000010 10000001 ? 00000000 01000000 00100000 00010000 00001000 10000111 00000000 00000000 ? 00000000 01000000 00100000 00010000 00001000 10000001 00000010 00000000 ? 00...
result:
ok correct! (10000 test cases)
Test #64:
score: 0
Accepted
time: 461ms
memory: 8272kb
input:
10000 9 0 111111111 101111111 111111111 111011111 111101111 111110111 111111111 111111111 111111110 0 111111111 101111111 111111111 111011111 111101111 111110111 111111111 111111111 111111110 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 110000000 010000000 101000000 000100000 000010000 000001000 100000100 100000010 000000001 ? 000000000 100001111 001000000 100001111 100001111 100001111 000000000 000000000 100001111 ? 000000000 100000011 00...
result:
ok correct! (10000 test cases)
Test #65:
score: 0
Accepted
time: 608ms
memory: 8308kb
input:
10000 6 0 111111 101111 110111 111100 111101 111101 0 101111 101111 110111 111100 111101 111101 0 011100 011100 011100 111101 011100 111111 0 111100 011111 011111 111111 111100 111111 0 111111 111100 011111 110100 111111 111111 0 6 0 111111 001111 010111 011011 011101 011110 0 001111 101111 110111 1...
output:
? 000000 110000 101000 100100 100010 100001 ? 110000 010000 001000 100100 000010 100001 ? 100011 100011 100011 000100 100011 000000 ? 100100 100100 100100 000000 100100 000001 ? 000000 101000 101000 000100 000000 000001 ! 000100 001000 010000 000100 000100 000001 ? 000000 110000 101000 100100 100010...
result:
ok correct! (10000 test cases)
Test #66:
score: 0
Accepted
time: 403ms
memory: 5168kb
input:
10000 7 0 1111111 1110010 1101111 1111010 1111011 1111101 1110011 0 1110010 1110010 1101111 1111010 1111011 1111101 1110011 0 1111111 1011111 1110111 1111000 0111010 0111010 1111111 0 1111111 1011111 0111110 1111111 0110111 0110111 1111111 0 1111111 1011111 1100010 1101000 1110000 0111111 1111110 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1010000 1100000 0010000 1001000 0000100 0000010 1000001 ? 0000000 0100000 1000111 0001000 1000111 1000111 0000000 ? 0000000 0100000 1000001 0000000 1001000 1001000 0000000 ? 0000000 0100000 1000010 0001000 1010000 1010000 0000001 ! 1000000 ...
result:
ok correct! (10000 test cases)
Test #67:
score: 0
Accepted
time: 404ms
memory: 5432kb
input:
10000 7 0 1111111 0011111 0101111 0110111 1111101 1111111 0111110 0 0011111 1011111 1101111 1110111 1111101 1111111 1111110 0 1111111 1111111 1111111 1111111 1111111 1111111 1111111 0 0111110 0111110 0111110 0111110 0111101 1111111 0111110 0 0111101 0111101 0111101 0111101 0111111 1111111 0111101 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1100000 0100000 0010000 0001000 1000100 1000010 0000001 ? 1000111 1000111 1000111 1000111 0000000 0000000 1000111 ? 1000001 1000001 1000001 1000001 0000100 0000010 1000001 ? 1000010 1000010 1000010 1000010 0000100 0000000 1000010 ! 0000100 ...
result:
ok correct! (10000 test cases)
Test #68:
score: 0
Accepted
time: 432ms
memory: 5364kb
input:
10000 7 0 1111111 0011111 0101111 0110111 0111011 0111101 0111110 0 1111111 1111111 1101111 1110111 1111011 1111101 1111110 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 ? 1100000 0100000 0010000 0001000 0000100 0000010 0000001 ? 0000000 1000111 1000111 1000111 1000111 1000111 1000111 ? 0000000 1001000 1001000 1001000 1001000 1001000 1001000 ? 0000000 1010000 0000000 1010000 1010000 0000000 0000000 ! 0100000 ...
result:
ok correct! (10000 test cases)
Test #69:
score: 0
Accepted
time: 395ms
memory: 5424kb
input:
10000 7 0 1111111 1011111 1101111 1001111 1111011 1001111 1111110 0 1011111 1011111 1101111 1001111 1111011 1001111 1111110 0 1001111 1111111 1001111 1110111 1001111 1111111 1001111 0 0111111 0111111 1001111 1110111 0111111 1001110 0111111 0 1001111 0111111 1111111 1110111 1001111 1111111 0111111 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1100000 0100000 0010000 1001000 0000100 1000010 0000001 ? 1000111 1000111 1000111 0001000 1000111 0000000 1000111 ? 1000001 1000001 1000001 0001000 1000001 0000010 1000001 ? 1000010 1000010 0000000 0001000 1000010 0000000 1000010 ! 0000010 ...
result:
ok correct! (10000 test cases)
Test #70:
score: 0
Accepted
time: 443ms
memory: 5420kb
input:
10000 8 0 11111111 10111111 11011111 11111100 11110111 11111011 11111110 11111110 0 10111111 10111111 11011111 11111100 11110111 11111011 11111110 11111110 0 01111100 01111100 11111111 11101111 01111100 01111100 11111111 01111100 0 11111100 11111100 01111110 11111111 01111111 11111100 11100110 01111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11000000 01000000 00100000 10010000 00001000 00000100 10000010 00000001 ? 10000111 10000111 10000111 00010000 10000111 10000111 00000000 10000111 ? 10011000 10011000 10000001 00000000 10011000 10011000 00000010 10011000 ? 10...
result:
ok correct! (10000 test cases)
Test #71:
score: 0
Accepted
time: 426ms
memory: 5380kb
input:
10000 8 0 11111111 10111111 11011111 11101111 11111111 11111011 11111101 11111110 0 11110111 11111111 11011111 11101111 10111111 11111011 11111101 11111110 0 11111111 01111111 11110111 11110111 11110111 11110111 01111111 01111111 0 11111111 11111110 01111111 01111111 11111111 11100111 01110111 01110...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11000000 01000000 00100000 00010000 10001000 00000100 00000010 00000001 ? 00000000 10000111 10000111 10000111 00001000 10000111 10000111 10000111 ? 00000000 10011000 10000001 10000001 00000000 10000001 10011000 10011000 ? 00...
result:
ok correct! (10000 test cases)
Test #72:
score: 0
Accepted
time: 479ms
memory: 5592kb
input:
10000 8 0 11111111 11111111 11011111 11101111 11111111 11111011 11111111 11111111 0 11111111 11111111 11111111 11101111 11111111 11111011 11111111 11111111 0 11111111 10111111 01111000 01111000 11111111 01111000 11111111 11111111 0 11111111 10111111 01100111 01100111 11111111 01100111 11111111 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10100000 11000000 00100000 00010000 10001000 00000100 10000010 10000001 ? 00000000 01000000 10000111 10000111 00001000 10000111 00000000 00000000 ? 00000000 01000000 10011000 10011000 00000000 10011000 00000010 00000001 ? 00...
result:
ok correct! (10000 test cases)
Test #73:
score: 0
Accepted
time: 438ms
memory: 5600kb
input:
10000 8 0 01011111 10011111 11111111 11001111 11110111 11011111 11011101 11011110 0 10010001 01111110 11111111 01111110 11111111 11111111 10010001 10010001 0 01101110 10010001 11111111 11111111 11111111 11111111 00000000 00000000 0 10000000 01111111 11111111 00010001 11111111 11111111 01111111 01111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11111111 00000000 00000000 00000000 11111111 11111111 11111111 11111111 ? 11111111 00000000 01101110 01101110 00000000 00000000 10010001 10010001 ? 11111111 00000000 00000000 01101110 00000000 10010001 00000000 00000000 ! 00...
result:
ok correct! (10000 test cases)
Test #74:
score: 0
Accepted
time: 457ms
memory: 5424kb
input:
10000 8 0 11111111 11111111 11011111 11101111 11111111 11011101 11111111 11111111 0 11011111 11111111 11011111 11101111 11111111 11011101 11111111 11111111 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 0 11111111 11111111 11111111 11111111 11111111 11111111 11111101 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10100000 11000000 00100000 00010000 10001000 10000100 10000010 10000001 ? 10000111 01000000 10000111 10000111 00001000 00000000 00000000 00000000 ? 10000001 01000000 10000001 10000001 00001000 00000100 00000010 00000000 ? 00...
result:
ok correct! (10000 test cases)
Test #75:
score: 0
Accepted
time: 457ms
memory: 5312kb
input:
10000 8 0 11111111 10111101 11111101 11101101 11110101 11111001 11111111 11111100 0 10111111 00111101 11111101 01101101 01110101 01111001 11111111 01111100 0 11111111 01110011 11111111 10001100 01110011 01110011 11111111 01110011 0 11111111 11110011 10001100 10000000 00001100 00001100 01111111 01111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11000000 01000000 10100000 00010000 00001000 00000100 10000010 00000001 ? 00000000 11111111 00000000 00000000 11111111 11111111 11111111 11111111 ? 00000000 11111111 10001100 10001100 00000000 00000000 01110011 01110011 ? 00...
result:
ok correct! (10000 test cases)
Test #76:
score: 0
Accepted
time: 415ms
memory: 5104kb
input:
10000 8 0 11111111 00111111 01011111 11111111 01110111 01111011 11111111 11111111 0 11111111 00111111 01011111 11111111 11110111 01111011 11111111 11111111 0 11111111 01011111 10111001 11111111 11111111 01011111 11111111 11111111 0 11111111 01011111 01011111 01011111 11111111 11111111 11111111 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11000000 01000000 00100000 10010000 00001000 00000100 10000010 10000001 ? 00000000 11111111 00000000 00000000 11111111 11111111 11111111 11111111 ? 00000000 11111111 10100000 10100000 00000000 00000000 01011111 01011111 ? 00...
result:
ok correct! (10000 test cases)
Test #77:
score: 0
Accepted
time: 1063ms
memory: 10308kb
input:
10000 9 0 111111111 101111111 110111111 110111111 111101111 111110111 111111011 111111101 111111110 0 101111111 101111111 110111111 110111111 111101111 111110111 111111011 111111101 111111110 0 111111111 110111111 110111111 111011111 011111111 011111111 110111111 110111111 110111111 0 111111111 1100...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 110000000 010000000 001000000 100100000 000010000 000001000 000000100 000000010 000000001 ? 100001111 100001111 100001111 000100000 100001111 100001111 100001111 100001111 100001111 ? 100000011 100000011 10...
result:
ok correct! (10000 test cases)
Test #78:
score: 0
Accepted
time: 1006ms
memory: 10336kb
input:
10000 9 0 111111111 101111111 110111111 111111111 111101111 111110111 111111011 111111111 111111110 0 101111111 101111111 110111111 111111111 111101111 111110111 111111011 111111111 111111110 0 011111111 011111111 111111111 111011111 011111111 111111111 111111111 111111111 111111111 0 011001111 0110...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 110000000 010000000 001000000 100100000 000010000 000001000 000000100 100000010 000000001 ? 100001111 100001111 100001111 000100000 100001111 100001111 100001111 000000000 100001111 ? 100110000 100110000 10...
result:
ok correct! (10000 test cases)
Test #79:
score: 0
Accepted
time: 992ms
memory: 10268kb
input:
10000 9 0 111111111 001111111 101111101 100111101 011101111 011110111 111111111 011111101 011111110 0 001111111 101111111 101111101 100111101 111101111 111110111 111111111 111111101 111111110 0 011111101 100111111 001110100 000110100 100111111 011111101 111111111 011111101 011111101 0 100111100 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 110000000 010000000 101000000 100100000 000010000 000001000 100000100 000000010 000000001 ? 100001111 100001111 001000000 000100000 100001111 100001111 000000000 100001111 100001111 ? 100110000 100000011 00...
result:
ok correct! (10000 test cases)
Test #80:
score: 0
Accepted
time: 906ms
memory: 10320kb
input:
10000 9 0 111111111 111111111 110111111 111011111 111101111 111111111 111111111 111111101 111111111 0 110111111 111111111 110111111 111011111 111101111 111111111 111111111 111111101 111111111 0 111111111 101111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 011111110 1011...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 101000000 110000000 001000000 000100000 000010000 100001000 100000100 000000010 100000001 ? 100001111 010000000 100001111 100001111 100001111 000000000 000000000 100001111 000000000 ? 100000011 010000000 10...
result:
ok correct! (10000 test cases)
Extra Test:
score: 0
Extra Test Passed