QOJ.ac
QOJ
ID | 题目 | 提交者 | 结果 | 用时 | 内存 | 语言 | 文件大小 | 提交时间 | 测评时间 |
---|---|---|---|---|---|---|---|---|---|
#329418 | #7788. Rook Detection | yz_ly | AC ✓ | 951ms | 5948kb | C++14 | 4.9kb | 2024-02-16 17:32:52 | 2024-02-16 17:32:53 |
Judging History
answer
#include<bits/stdc++.h>
using namespace std;
inline int read(){
char ch=getchar();
int f=1,x=0;
while(ch<'0'||ch>'9'){
if(ch=='-')
f=-f;
ch=getchar();
}
while(ch>='0'&&ch<='9'){
x=x*10+ch-'0';
ch=getchar();
}
return f*x;
}
inline void work(int k){
if(k<0){
putchar('-');
k=-k;
}
if(k>9)
work(k/10);
putchar(k%10+'0');
}
/*
*/
int t,n,c[505][505],d[505][505],id[505];
pair<int,int> q[505];
vector<pair<int,int> > ans;
void init(){
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
c[i][j]=0;
}
}
}
void ask(){
puts("?");
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
work(c[i][j]);
}
putchar('\n');
}
fflush(stdout);
}
void report(){
puts("!");
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
work(c[i][j]);
}
putchar('\n');
}
fflush(stdout);
int c;
scanf("%d",&c);
if(c){
if(n==5)
exit(-1);
exit(0);
}
}
void receive(){
int c;
scanf("%d",&c);
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
scanf("%1d",d[i]+j);
}
}
}
void solve(int N){
for(int i=1;i<=n;i++){
q[i]=make_pair(1,N);
}
while(1){
int flag=0;
for(int i=1;i<=n;i++){
if(q[i].second!=q[i].first)
flag=1;
}
if(!flag)
break;
init();
for(int i=1;i<=n;i++){
if(q[i].second!=q[i].first){
int mid=(q[i].second+q[i].first)>>1;
for(int j=mid+1;j<=q[i].second;j++){
c[id[j]][i]=1;
}
}
c[id[N+1]][i]=1;
}
ask();
receive();
for(int i=1;i<=n;i++){
if(q[i].second!=q[i].first){
int mid=(q[i].second+q[i].first)>>1;
if(d[id[N+1]][i])
q[i]=make_pair(mid+1,q[i].second);
else
q[i]=make_pair(q[i].first,mid);
}
}
}
init();
for(int i=1;i<=n;i++){
c[id[q[i].first]][i]=1;
}
report();
}
int main(){
t=read();
while(t--){
n=read();
init();
for(int i=2;i<=n;i++){
c[i][1]=1;
c[i][i]=1;
}
ask();
receive();
if(!d[1][1]){
for(int i=1;i<n;i++){
id[i]=i+1;
}
id[n]=1;
solve(n-1);
continue;
}
init();
int fff=0;
for(int i=2;i<=n;i++){
if(d[i][i])
c[i][i]=c[i][1]=1;
else
c[i][i]=c[1][i]=1,fff=1;
}
int ff=0,cnt=0;
if(!fff){
ans.clear();
init();
for(int i=1;i<=n;i++){
c[i][i]=1;
}
ask();
receive();
for(int i=2;i<=n;i++){
if(d[i][i])
ans.emplace_back(make_pair(i,i));
else
ans.emplace_back(make_pair(i,1));
}
if(d[1][1])
ans.emplace_back(make_pair(1,1));
else{
int l=2,r=n;
while(l<r){
int mid=(l+r)>>1;
init();
for(int i=mid+1;i<=n;i++){
c[1][i]=1;
}
c[1][1]=1;
ask();
receive();
if(d[1][1])
l=mid+1;
else
r=mid;
}
ans.emplace_back(make_pair(1,l));
}
init();
for(auto i:ans){
c[i.first][i.second]=1;
}
report();
continue;
}
else
c[1][1]=1;
ask();
receive();
int f=0;
for(int i=2;i<=n;i++){
if(c[1][i]&&!d[i][1]){
f=i;
break;
}
}
if(f){
for(int i=1;i<n;i++){
id[i]=i+(i>=f);
}
id[n]=f;
solve(n-1);
continue;
}/*否则每行都有,直接二分*/
ans.clear();
vector<int> gg;
for(int i=2;i<=n;i++){
if(c[1][i]){
if(d[i][i]){
ans.emplace_back(1,i);
ff=1;
}
id[++cnt]=i;
}
else
gg.emplace_back(i);
}
if(!ff){
for(int i=2;i<=n;i++){
if(c[1][i]&&d[1][i]){
ans.emplace_back(1,1);
ff=1;
break;
}
}
if(!ff)
id[++cnt]=1;
}
for(int i=1;i<=cnt;i++){
q[i]=make_pair(2,n);
}
while(1){
int flag=0;
for(int i=1;i<=cnt;i++){
if(q[i].second!=q[i].first)
flag=1;
}
if(!flag)
break;
init();
for(int i=1;i<=cnt;i++){
if(q[i].second!=q[i].first){
int mid=(q[i].second+q[i].first)>>1;
for(int j=mid+1;j<=q[i].second;j++){
c[id[i]][j]=1;
}
}
c[id[i]][1]=1;
}
vector<int> hh,bb;
for(auto i:gg){
int flag=0;
for(int j=1;j<=n;j++){
if(c[j][i])
flag=1;
}
if(!flag){
c[i][i]=1;
bb.emplace_back(i);
}
else
hh.emplace_back(i);
}
gg=hh;
ask();
receive();
for(int i=1;i<=cnt;i++){
if(q[i].second!=q[i].first){
int mid=(q[i].second+q[i].first)>>1;
if(d[id[i]][1])
q[i]=make_pair(mid+1,q[i].second);
else
q[i]=make_pair(q[i].first,mid);
}
}
for(auto i:bb){
if(d[i][i])
ans.emplace_back(make_pair(i,i));
else
ans.emplace_back(make_pair(i,1));
}
}
if(gg.size()){
init();
for(auto i:gg){
c[i][i]=1;
}
ask();
receive();
for(auto i:gg){
if(d[i][i])
ans.emplace_back(make_pair(i,i));
else
ans.emplace_back(make_pair(i,1));
}
}
init();
for(int i=1;i<=cnt;i++){
c[id[i]][q[i].first]=1;
}
for(auto i:ans){
c[i.first][i.second]=1;
}
report();
}
return 0;
}
这程序好像有点Bug,我给组数据试试?
详细
Test #1:
score: 100
Accepted
time: 1ms
memory: 3636kb
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: 59ms
memory: 3684kb
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: 70ms
memory: 3964kb
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 0000 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: 71ms
memory: 3688kb
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: 73ms
memory: 3748kb
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: 78ms
memory: 3688kb
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 1111 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 ? 1011 0000 0000 0000 ! 0010 0100 1000 0001 ? 0000 1100 1010 1001 ? 1001 1100 1010 0001 ? 0000 0100 0010 1001 ? 0000 0000 0000 1010 ! 0001 1000 0010 0010 ? 0000 1100 1010 1001 ? 1001 1100 1010 0001 ? 0000 0100 0010 1001 ? 0000 0000 00...
result:
ok correct! (10000 test cases)
Test #7:
score: 0
Accepted
time: 659ms
memory: 5664kb
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 0100 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 ? 1011 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: 570ms
memory: 5620kb
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 ? 111011000 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: 439ms
memory: 5536kb
input:
10000 5 0 11111 10111 11111 11111 11111 0 11111 10111 11111 11111 11111 0 11111 11111 11011 11111 11111 0 11111 01110 11111 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 00000 00010 00000 ? 00000 00000 00000 00000 00001 ! 10000 00010 10000 00010 10000 ? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11001100 01000000 10100000 10010...
result:
ok correct! (10000 test cases)
Test #10:
score: 0
Accepted
time: 531ms
memory: 5568kb
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 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100110000 110000000 101000000 000100000 000010000 100001000 100000100 100000010 100000001 ? 000000000 010000000 001000000 100001111 100001111 000000000 000000000 000000000 000000000 ? 000000000 000000000 00...
result:
ok correct! (10000 test cases)
Test #11:
score: 0
Accepted
time: 526ms
memory: 5648kb
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: 228ms
memory: 5512kb
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: 383ms
memory: 5664kb
input:
10000 6 0 111111 101111 110111 111011 100010 111110 0 111111 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 10010111 11000110 10100110 11101111 ...
output:
? 000000 110000 101000 100100 100010 100001 ? 111101 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: 350ms
memory: 5328kb
input:
10000 6 0 111111 001111 010111 011011 011101 011110 0 111111 010101 111111 000001 000111 000100 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 ? 111111 010000 001000 000100 000010 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: 416ms
memory: 5448kb
input:
10000 9 0 111111111 111111111 111111111 111111111 111111111 111110111 111111011 111111111 111111110 0 111111111 111111111 111111111 111111111 111111111 111110111 011111011 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 ? 100001101 110000000 101000000 100100000 100010000 000001000 000000100 100000010 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: 293ms
memory: 5584kb
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 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 1000000 0010000 1000000 1000000 1000000 1000000 ? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1100100 0100000 1010000 1001000 0000100 1000010 1000001 ? 0000000 ...
result:
ok correct! (10000 test cases)
Test #17:
score: 0
Accepted
time: 360ms
memory: 5416kb
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 01111111 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: 800ms
memory: 5672kb
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: 746ms
memory: 5720kb
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 ? 11110010 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: 615ms
memory: 5668kb
input:
10000 7 0 1111111 0011111 0101111 0110111 0111011 0111101 0111110 0 1111111 1011111 1111111 1110111 1111111 1111101 1111110 0 1111111 0111101 1010111 1111111 0111101 1010111 1010111 0 1111111 0110111 1111111 1111111 0110111 0111111 0111111 0 1111111 1010101 0111111 0111111 1010101 0111101 0111101 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1111111 0100000 0010000 0001000 0000100 0000010 0000001 ? 0000000 1000111 1000111 1000111 1000111 1000111 1000111 ? 0000000 1001000 1000001 1000001 1001000 1000001 1000001 ? 0000000 1010000 1000000 1000000 1010000 1000010 1000010 ! 0010100 ...
result:
ok correct! (10000 test cases)
Test #21:
score: 0
Accepted
time: 659ms
memory: 5896kb
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: 774ms
memory: 5716kb
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 0011001 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: 540ms
memory: 5928kb
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 ? 100111 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: 295ms
memory: 4696kb
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 11111 10111 11011 11111 11101 0 11111 01101 01101 11111 11111 0 11111 11110 01111 11011 11111 0 11111 11111 11111 11111 11110 ...
output:
? 00000 11000 10100 10010 10001 ? 11111 01000 00100 00010 00001 ? 00000 10011 10011 10011 10011 ? 00000 10100 10100 10001 10001 ! 10000 00100 01000 00001 00010 ? 00000 11000 10100 10010 10001 ? 11110 01000 00100 00010 10001 ? 00000 10011 10011 10011 00000 ? 00000 10100 10100 10001 00000 ? 00000 0000...
result:
ok correct! (10000 test cases)
Test #25:
score: 0
Accepted
time: 342ms
memory: 4680kb
input:
10000 6 0 111111 101111 110111 111111 111011 111110 0 111011 101111 111111 110111 110011 111110 0 111111 111011 111011 111100 111111 011111 0 111111 011111 111111 111111 111101 011011 0 111111 011111 011111 111111 111111 010111 0 6 0 111111 111111 110111 111011 111101 111110 0 111111 110111 111111 1...
output:
? 000000 110000 101000 100100 100010 100001 ? 111001 010000 001000 100100 100010 000001 ? 000000 100011 100011 000100 000000 100011 ? 000000 100001 100001 000000 000010 100100 ? 000000 100000 100000 000000 000000 101000 ! 001000 000010 000001 000100 100000 010000 ? 000000 110000 101000 100100 100010...
result:
ok correct! (10000 test cases)
Test #26:
score: 0
Accepted
time: 305ms
memory: 4692kb
input:
10000 7 0 1111111 1111111 1101111 1110111 1111011 1111101 1011111 0 1011111 1111011 1101111 1110111 1111111 1111101 1011011 0 1111111 1111100 1011111 0111011 0111011 1011111 1111111 0 1111111 1111111 0111111 0111111 1111110 1110111 1111111 0 1111111 1111111 1101111 1111101 0111111 0111111 1111110 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1011110 1100000 0010000 0001000 0000100 0000010 1000001 ? 0000000 0100000 1000111 1000111 1000111 1000111 0000000 ? 0000000 0000000 1000001 1001000 1001000 1000001 0000000 ? 0000000 0000000 1000010 1010000 1000000 1000000 0000001 ! 0000100 ...
result:
ok correct! (10000 test cases)
Test #27:
score: 0
Accepted
time: 836ms
memory: 5648kb
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 ? 11111111 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: 814ms
memory: 5920kb
input:
10000 8 0 11111111 10111111 11011111 11110100 11111100 11111011 11110110 11110101 0 11110100 10111111 11111111 11010100 11011100 11111011 11010110 11010101 0 11111111 11110111 01111100 11101111 11111011 01111100 11111111 11111111 0 11111111 01111110 01110111 11111111 11111111 11111101 11101111 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11100100 01000000 00100000 10010000 10001000 00000100 10000010 10000001 ? 00000000 10000111 10000111 00010000 00001000 10000111 00000000 00000000 ? 00000000 10000001 10011000 00000000 00000000 10011000 00000010 00000000 ? 00...
result:
ok correct! (10000 test cases)
Test #29:
score: 0
Accepted
time: 854ms
memory: 5608kb
input:
10000 8 0 11111111 10111111 11011111 11111011 11110111 11111111 11111101 11111110 0 11111011 10111111 11011111 11110011 11111111 11110111 11111101 11111110 0 11111111 01111011 01111011 11101111 11111111 11111111 11111111 01111011 0 11111111 11111010 01110111 11111111 01111111 11101110 11101011 01110...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11101011 01000000 00100000 10010000 00001000 10000100 00000010 00000001 ? 00000000 10000111 10000111 00010000 10000111 00000000 10000111 10000111 ? 00000000 10011000 10011000 00000000 10000001 00000100 10000001 10011000 ? 00...
result:
ok correct! (10000 test cases)
Test #30:
score: 0
Accepted
time: 814ms
memory: 5708kb
input:
10000 8 0 11111111 10111111 11101101 11011101 11110111 11001101 11001111 11111110 0 11001101 10111111 11101100 11011100 11110111 11001100 11001110 11111111 0 11111111 01111100 11101011 11011011 01111100 11111111 11111111 11001111 0 11111111 11111101 11111111 11111111 01101111 11111011 11110111 01111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11001001 01000000 10100000 10010000 00001000 10000100 10000010 00000001 ? 00000000 10000111 00100000 00010000 10000111 00000000 00000000 10000111 ? 00000000 10011000 00000000 00000000 10011000 00000100 00000010 10000001 ? 00...
result:
ok correct! (10000 test cases)
Test #31:
score: 0
Accepted
time: 797ms
memory: 5920kb
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 ? 11111111 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: 906ms
memory: 5920kb
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 ? 111101111 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: 778ms
memory: 5648kb
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 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 101111111 110000000 001000000 000100000 000010000 000001000 000000100 000000010 000000001 ? 000000000 010000000 100001111 100001111 100001111 100001111 100001111 100001111 100001111 ? 000000000 000000000 10...
result:
ok correct! (10000 test cases)
Test #34:
score: 0
Accepted
time: 880ms
memory: 5660kb
input:
10000 9 0 111111111 101111111 110111111 111011111 111111111 111110111 111111011 111111101 111111110 0 111111111 101111111 110111111 111111111 111011111 111110111 111111011 111111101 111111110 0 111111111 111111111 011111111 011111111 111101111 111111111 111111111 011111111 111111111 0 111111111 0111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 111101111 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 #35:
score: 0
Accepted
time: 887ms
memory: 5924kb
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 ? 111111011 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: 809ms
memory: 5656kb
input:
10000 9 0 111111111 111111011 110111111 111011111 111101111 111110111 111111111 111111101 111111110 0 111111011 111101011 110111111 111011111 111111111 111110111 111101111 111111101 111111110 0 111111111 101111111 111111111 111111111 011111011 111111111 111111111 011111011 011111011 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 101111011 110000000 001000000 000100000 000010000 000001000 100000100 000000010 000000001 ? 000000000 010000000 100001111 100001111 100001111 100001111 000000000 100001111 100001111 ? 000000000 000000000 10...
result:
ok correct! (10000 test cases)
Test #37:
score: 0
Accepted
time: 335ms
memory: 4700kb
input:
10000 7 0 1111111 1011111 1111111 1110111 1111011 1111101 1111110 0 1111111 0011011 1111011 1110111 1111111 1111101 1111110 0 1111111 0111010 1111111 1111111 1111111 1111111 1111111 0 1111111 0010011 1111111 1111111 1111111 1111111 1111110 0 1111111 1100000 1111111 1111111 1111111 1111111 1111111 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1101111 0100000 1010000 0001000 0000100 0000010 0000001 ? 0000000 1111111 0000000 0000000 1111111 1111111 1111111 ? 0000000 1111111 0000000 1000101 0000000 0000000 0111010 ? 0000000 1111111 1000100 0000000 0000000 0101000 0000000 ! 0000100 ...
result:
ok correct! (10000 test cases)
Test #38:
score: 0
Accepted
time: 359ms
memory: 4948kb
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 11111111 11111111 01111111 11111111 01110111 01111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11001111 01000000 10100000 10010000 00001000 00000100 00000010 00000001 ? 00000000 10000111 00100000 00010000 10000111 10000111 10000111 10000111 ? 00000000 10011000 00000000 00000000 10000001 10000001 10011000 10000001 ? 00...
result:
ok correct! (10000 test cases)
Test #39:
score: 0
Accepted
time: 405ms
memory: 4680kb
input:
10000 8 0 11111111 10111111 11011111 11101111 11110111 11111011 11111111 11111110 0 11111111 10111111 11111111 11101111 11110111 11111111 11111111 11111111 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 ? 11111101 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: 371ms
memory: 4648kb
input:
10000 8 0 11111111 10111111 11011111 11101111 11110111 11111111 11111101 11111101 0 11111111 10111111 11111111 11101111 11110111 11111111 11111101 11111101 0 11111111 01111101 01111101 11111111 01111101 11111111 11111111 11111111 0 11111111 11111101 11111101 01111111 01111111 11111111 11111101 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11111010 01000000 00100000 00010000 00001000 10000100 00000010 10000001 ? 00000000 10000111 10000111 10000111 10000111 00000000 10000111 00000000 ? 00000000 10011000 10011000 10000001 10011000 00000100 10000001 00000000 ? 00...
result:
ok correct! (10000 test cases)
Test #41:
score: 0
Accepted
time: 885ms
memory: 5920kb
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 ? 101100111 110000000 001000000 000100000 100010000 100001000 000000100 000000010 000000001 ? 000000000 010000000 100001111 100001111 000010000 000000000 100001111 100001111 100001111 ? 000000000 000000000 10...
result:
ok correct! (10000 test cases)
Test #42:
score: 0
Accepted
time: 938ms
memory: 5628kb
input:
10000 9 0 111111111 110111101 101111101 100111101 111101111 100111101 111111011 111111101 111111111 0 111101001 110111101 101111101 100111101 111101111 100111101 111111011 111111101 111111111 0 100111111 110110001 101110001 100110001 100111111 111111111 011111101 100111111 111111111 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100010110 110000000 101000000 100100000 000010000 100001000 000000100 000000010 100000001 ? 100001111 010000000 001000000 000100000 100001111 000000000 100001111 100001111 000000000 ? 100000011 000000000 00...
result:
ok correct! (10000 test cases)
Test #43:
score: 0
Accepted
time: 905ms
memory: 5712kb
input:
10000 9 0 111111111 101111111 111111111 111011111 111101111 111110111 111111111 111111101 111111110 0 101000100 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 ? 110111011 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: 272ms
memory: 4688kb
input:
10000 7 0 1111111 1111111 1101111 1110111 1111011 1111111 1111110 0 1111111 1111111 1101111 1111111 1111011 1111111 1111110 0 1111111 1111111 1111111 1111111 1111111 1111111 1111111 0 1111111 1111111 0111111 1111111 0111111 1111101 0111111 0 1111111 1111111 1111111 0111111 1111111 1111111 1111111 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1011101 1100000 0010000 0001000 0000100 1000010 0000001 ? 0000000 0100000 1000111 1000111 1000111 0000000 1000111 ? 0000000 0000000 1000001 1000001 1000001 0000010 1000001 ? 0000000 0000000 1000010 1000000 1000010 0000000 1000010 ! 0001000 ...
result:
ok correct! (10000 test cases)
Test #45:
score: 0
Accepted
time: 333ms
memory: 4700kb
input:
10000 8 0 11111111 11111111 11011111 11101111 11111111 11111011 11111101 11111110 0 11111111 11111111 11011111 11101111 11111111 11111111 11111101 11111110 0 11111111 10111111 11111111 01111101 11110111 01111101 11111111 01111101 0 11111111 11111111 11110111 11111110 11111111 01101111 01111111 01101...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10110111 11000000 00100000 00010000 10001000 00000100 00000010 00000001 ? 00000000 01000000 10000111 10000111 00001000 10000111 10000111 10000111 ? 00000000 00000000 10000001 10011000 00000000 10011000 10000001 10011000 ? 00...
result:
ok correct! (10000 test cases)
Test #46:
score: 0
Accepted
time: 327ms
memory: 4924kb
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 ? 11010110 01000000 10100000 00010000 10001000 00000100 00000010 10000001 ? 00000000 10000111 00100000 10000111 00001000 10000111 10000111 00000000 ? 00000000 10011000 00000000 10000001 00000000 10011000 10011000 00000000 ? 00...
result:
ok correct! (10000 test cases)
Test #47:
score: 0
Accepted
time: 354ms
memory: 4648kb
input:
10000 8 0 11111111 10111111 11011111 11111111 11110111 11111011 11111101 11111110 0 11111111 10111111 11011111 11111111 11110111 11111111 11111101 11111110 0 11111111 11111111 11111111 11101111 11111111 01111111 11111111 11111111 0 11111111 01111111 01111111 11111111 01111111 11111110 11111111 01111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11101111 01000000 00100000 10010000 00001000 00000100 00000010 00000001 ? 00000000 10000111 10000111 00010000 10000111 10000111 10000111 10000111 ? 00000000 10000001 10000001 00000000 10000001 10011000 10000001 10000001 ? 00...
result:
ok correct! (10000 test cases)
Test #48:
score: 0
Accepted
time: 951ms
memory: 5644kb
input:
10000 9 0 111111111 101111111 110111111 111011111 111101111 111110111 111111111 111111101 111111111 0 111111111 101111111 111111111 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 ? 111111010 010000000 001000000 000100000 000010000 000001000 100000100 000000010 100000001 ? 000000000 100001111 100001111 100001111 100001111 100001111 000000000 100001111 000000000 ? 000000000 100000011 10...
result:
ok correct! (10000 test cases)
Test #49:
score: 0
Accepted
time: 856ms
memory: 5916kb
input:
10000 9 0 111111111 111111111 111111111 111111111 111101111 111110111 111111011 111111111 111111111 0 111111101 111111111 111111111 111111111 111101111 111110111 111111111 111111111 111111111 0 111111111 111111111 111111111 111011111 011111000 011111000 111111111 111111111 111111111 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100011100 110000000 101000000 100100000 000010000 000001000 000000100 100000010 100000001 ? 000000000 010000000 001000000 000100000 100001111 100001111 100001111 000000000 000000000 ? 000000000 000000000 00...
result:
ok correct! (10000 test cases)
Test #50:
score: 0
Accepted
time: 864ms
memory: 5652kb
input:
10000 9 0 111111111 111111111 110111111 111111111 111111111 111110111 111111011 111111101 111111111 0 111111111 111111111 110111111 111111111 111111111 111110111 111111111 111111101 111111111 0 111111111 111111111 111111111 111111111 111101111 011110110 011110110 111111111 111111111 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 101001110 110000000 001000000 100100000 100010000 000001000 000000100 000000010 100000001 ? 000000000 010000000 100001111 000100000 000010000 100001111 100001111 100001111 000000000 ? 000000000 000000000 10...
result:
ok correct! (10000 test cases)
Test #51:
score: 0
Accepted
time: 143ms
memory: 4692kb
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: 252ms
memory: 4696kb
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: 276ms
memory: 4688kb
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: 300ms
memory: 4700kb
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 11111111 11111111 11111111 11111111 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11010000 01000000 10100000 00010000 10001000 10000100 10000010 10000001 ? 00000000 10000111 00100000 10000111 00001000 00000000 00000000 00000000 ? 00000000 10000001 00000000 10000001 00000000 00000100 00000010 00000000 ? 00...
result:
ok correct! (10000 test cases)
Test #55:
score: 0
Accepted
time: 195ms
memory: 4764kb
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: 811ms
memory: 5680kb
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 000000000 00...
result:
ok correct! (10000 test cases)
Test #57:
score: 0
Accepted
time: 796ms
memory: 5936kb
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: 462ms
memory: 5932kb
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 1111...
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 000000000 00...
result:
ok correct! (10000 test cases)
Test #59:
score: 0
Accepted
time: 605ms
memory: 5668kb
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: 739ms
memory: 5612kb
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: 807ms
memory: 5728kb
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 1111111 0111110 1111011 1111111 1111111 0 1111111 0111111 1111111 1111111 1111111 1111111 1111111 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1101000 0100000 1010000 0001000 1000100 1000010 1000001 ? 0000000 1000111 0010000 1000111 0000000 0000000 0000000 ? 0000000 1000001 0000000 1000001 0000100 0000010 0000000 ? 0000000 1000010 0000000 1000010 0000000 0000000 0000001 ! 0100000 ...
result:
ok correct! (10000 test cases)
Test #62:
score: 0
Accepted
time: 690ms
memory: 5620kb
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: 320ms
memory: 5948kb
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 11111111 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 00000000 00000000 00000000 00000000 10000001 00000010 00000000 ? 00...
result:
ok correct! (10000 test cases)
Test #64:
score: 0
Accepted
time: 311ms
memory: 5648kb
input:
10000 9 0 111111111 101111111 111111111 111011111 111101111 111110111 111111111 111111111 111111110 0 111111111 101111111 111111111 111111111 111101111 111110111 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 ? 110111001 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: 557ms
memory: 5328kb
input:
10000 6 0 111111 101111 110111 111100 111101 111101 0 100101 101111 110111 111100 111101 111101 0 011100 011100 011100 111101 011100 111111 0 111100 011111 011111 111111 111100 111111 0 011111 111101 011111 111111 011111 111111 0 6 0 111111 001111 010111 011011 011101 011110 0 111111 101111 110111 1...
output:
? 000000 110000 101000 100100 100010 100001 ? 111010 010000 001000 100100 000010 100001 ? 100011 100011 100011 000100 100011 000000 ? 100100 100100 100100 000000 100100 000001 ? 100000 101000 101000 000000 100000 000000 ! 000100 001000 010000 000100 000100 000001 ? 000000 110000 101000 100100 100010...
result:
ok correct! (10000 test cases)
Test #66:
score: 0
Accepted
time: 309ms
memory: 4964kb
input:
10000 7 0 1111111 1110010 1101111 1111010 1111011 1111101 1110011 0 1110110 1110010 1101111 1111010 1111011 1111101 1110011 0 1111111 1011111 1110111 1111000 0111010 0111010 1111111 0 1111111 1111111 0111110 1111111 0110111 0110111 1111111 0 1111111 1111111 1101010 1111111 1111000 0111111 1111110 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1010110 1100000 0010000 1001000 0000100 0000010 1000001 ? 0000000 0100000 1000111 0001000 1000111 1000111 0000000 ? 0000000 0000000 1000001 0000000 1001000 1001000 0000000 ? 0000000 0000000 1000010 0000000 1010000 1010000 0000001 ! 1000000 ...
result:
ok correct! (10000 test cases)
Test #67:
score: 0
Accepted
time: 327ms
memory: 4700kb
input:
10000 7 0 1111111 0011111 0101111 0110111 1111101 1111111 0111110 0 0000110 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 1111111 1111111 0111101 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1111001 0100000 0010000 0001000 1000100 1000010 0000001 ? 1000111 1000111 1000111 1000111 0000000 0000000 1000111 ? 1000001 1000001 1000001 1000001 0000100 0000010 1000001 ? 1000010 1000010 1000010 1000010 0000000 0000000 1000010 ! 0000100 ...
result:
ok correct! (10000 test cases)
Test #68:
score: 0
Accepted
time: 344ms
memory: 4740kb
input:
10000 7 0 1111111 0011111 0101111 0110111 0111011 0111101 0111110 0 1111111 1111111 1101111 1110111 1111111 1111101 1111111 0 1111111 0111000 0111000 0111000 0111000 0111000 0111000 0 1111111 0111111 1111101 0111111 0111111 1111101 1111101 0 1111111 1111101 0111111 1111101 1111101 0111111 0111111 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1111111 0100000 0010000 0001000 0000100 0000010 0000001 ? 0000000 1000111 1000111 1000111 1000111 1000111 1000111 ? 0000000 1001000 1001000 1001000 1001000 1001000 1001000 ? 0000000 1010000 1000000 1010000 1010000 1000000 1000000 ! 0100101 ...
result:
ok correct! (10000 test cases)
Test #69:
score: 0
Accepted
time: 335ms
memory: 4748kb
input:
10000 7 0 1111111 1011111 1101111 1001111 1111011 1001111 1111110 0 1001010 1011111 1101111 1001111 1111011 1001111 1111110 0 1001111 1111111 1001111 1110111 1001111 1111111 1001111 0 0111111 0111111 1001111 1111111 0111111 1001110 0111111 0 1001111 0111111 0111111 1111111 1001111 1111111 0111111 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1110101 0100000 0010000 1001000 0000100 1000010 0000001 ? 1000111 1000111 1000111 0001000 1000111 0000000 1000111 ? 1000001 1000001 1000001 0000000 1000001 0000010 1000001 ? 1000010 1000010 1000000 0000000 1000010 0000000 1000010 ! 0000010 ...
result:
ok correct! (10000 test cases)
Test #70:
score: 0
Accepted
time: 364ms
memory: 4756kb
input:
10000 8 0 11111111 10111111 11011111 11111100 11110111 11111011 11111110 11111110 0 10010010 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 ? 11101101 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: 380ms
memory: 4648kb
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 ? 11110111 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: 402ms
memory: 4964kb
input:
10000 8 0 11111111 11111111 11011111 11101111 11111111 11111011 11111111 11111111 0 11111111 11111111 11111111 11101111 11111111 11111111 11111111 11111111 0 11111111 10111111 01111000 01111000 11111111 01111000 11111111 11111111 0 11111111 11111111 01100111 01100111 11111111 01100111 11111111 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10110100 11000000 00100000 00010000 10001000 00000100 10000010 10000001 ? 00000000 01000000 10000111 10000111 00001000 10000111 00000000 00000000 ? 00000000 00000000 10011000 10011000 00000000 10011000 00000010 00000001 ? 00...
result:
ok correct! (10000 test cases)
Test #73:
score: 0
Accepted
time: 324ms
memory: 4924kb
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: 351ms
memory: 4708kb
input:
10000 8 0 11111111 11111111 11011111 11101111 11111111 11011101 11111111 11111111 0 11001111 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 ? 10110000 11000000 00100000 00010000 10001000 10000100 10000010 10000001 ? 10000111 01000000 10000111 10000111 00001000 00000000 00000000 00000000 ? 10000001 00000000 10000001 10000001 00000000 00000100 00000010 00000000 ? 00...
result:
ok correct! (10000 test cases)
Test #75:
score: 0
Accepted
time: 365ms
memory: 4684kb
input:
10000 8 0 11111111 10111101 11111101 11101101 11110101 11111001 11111111 11111100 0 11111101 00110001 11110001 01100001 01111001 01110101 11111111 01110000 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 ? 11011101 01000000 10100000 00010000 00001000 00000100 10000010 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: 341ms
memory: 4748kb
input:
10000 8 0 11111111 00111111 01011111 11111111 01110111 01111011 11111111 11111111 0 11111111 00011111 01111111 11111111 11110111 01011011 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 ? 11101100 01000000 00100000 10010000 00001000 00000100 10000010 10000001 ? 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: 880ms
memory: 5604kb
input:
10000 9 0 111111111 101111111 110111111 110111111 111101111 111110111 111111011 111111101 111111110 0 111111111 101111111 110111111 110101110 111111111 111110111 111111011 111111101 111111111 0 111111111 110111111 110111111 111011111 011111110 011111110 110111111 110111111 110111111 0 111111111 1100...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 111011111 010000000 001000000 100100000 000010000 000001000 000000100 000000010 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: 860ms
memory: 5648kb
input:
10000 9 0 111111111 101111111 110111111 111111111 111101111 111110111 111111011 111111111 111111110 0 111111111 101111111 111111111 111111111 111101111 111110111 111111011 111111111 111111110 0 111111111 011111111 111111111 111011111 011111111 111111111 111111111 111111111 111111111 0 111111111 0110...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 111011101 010000000 001000000 100100000 000010000 000001000 000000100 100000010 000000001 ? 000000000 100001111 100001111 000100000 100001111 100001111 100001111 000000000 100001111 ? 000000000 100110000 10...
result:
ok correct! (10000 test cases)
Test #79:
score: 0
Accepted
time: 839ms
memory: 5664kb
input:
10000 9 0 111111111 001111111 101111101 100111101 011101111 011110111 111111111 011111101 011111110 0 001100100 101111111 101111101 100111101 111101111 111110111 111111111 111111101 111111110 0 011111101 100111111 001110100 000110100 100111111 011111101 111111111 011111101 011111101 0 101111100 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 110011011 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: 811ms
memory: 5608kb
input:
10000 9 0 111111111 111111111 110111111 111011111 111101111 111111111 111111111 111111101 111111111 0 111111111 111111111 110111111 111111111 111111111 111111111 111111111 111111101 111111111 0 111111111 101111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 101110010 110000000 001000000 000100000 000010000 100001000 100000100 000000010 100000001 ? 000000000 010000000 100001111 100001111 100001111 000000000 000000000 100001111 000000000 ? 000000000 000000000 10...
result:
ok correct! (10000 test cases)
Extra Test:
score: 0
Extra Test Passed