QOJ.ac

QOJ

ID题目提交者结果用时内存语言文件大小提交时间测评时间
#807477#9188. Light Bulbsucup-team00422 602ms3892kbC++237.6kb2024-12-10 00:58:022024-12-10 00:58:03

Judging History

你现在查看的是最新测评结果

  • [2024-12-10 00:58:03]
  • 评测
  • 测评结果:22
  • 用时:602ms
  • 内存:3892kb
  • [2024-12-10 00:58:02]
  • 提交

answer

#include <bits/stdc++.h>

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;

std::mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());

constexpr bool debug = false;

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    // std::fclose(stderr);
    
    int N;
    std::cin >> N;
    
    std::vector<std::string> lights(N);
    if (debug) {
        // for (int i = 0; i < N; i++) {
        //     std::cin >> lights[i];
        // }
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                lights[i] += "HV"[rng() % 2];
            }
        }
    }
    
    std::vector<std::array<int, 3>> determined;
    std::vector<std::array<int, 2>> candidates;
    std::vector<int> possible {0};
    
    int cnt[2] {};
    
    std::vector lit(N, std::vector<bool>(N));
    
    std::vector type(N, std::vector<int>(N, -1));
    std::vector candId(N, std::vector<int>(N, -1));
    
    auto calc = [&](const std::vector<std::array<int, 2>> &q, int s) -> int {
        std::vector<bool> row(N), col(N);
        for (auto [x, y] : q) {
            if (type[x][y] != -1) {
                if (type[x][y] == 0) {
                    row[x] = true;
                } else {
                    col[y] = true;
                }
            } else {
                assert(candId[x][y] != -1);
                if (s >> candId[x][y] & 1) {
                    col[y] = true;
                } else {
                    row[x] = true;
                }
            }
        }
        return N * N - std::count(row.begin(), row.end(), false) * std::count(col.begin(), col.end(), false);
    };
    
    int rounds = 0;
    
    while (cnt[0] < N && cnt[1] < N) {
        if (debug) {
            rounds++;
            std::cerr << "candidates : " << candidates.size() << ", possibilities : " << possible.size() << "\n";
            for (auto [x, y] : candidates) {
                std::cerr << "(" << x << ", " << y << ") ";
            }
            std::cerr << "\n";
            for (auto s : possible) {
                for (int i = 0; i < candidates.size(); i++) {
                    std::cerr << (s >> i & 1);
                }
                std::cerr << " ";
            }
            std::cerr << "\n";
            
            int fact = 0;
            for (auto [x, y] : candidates) {
                if (lights[x][y] == 'V') {
                    fact |= 1 << candId[x][y];
                }
            }
            
            assert(std::find(possible.begin(), possible.end(), fact) != possible.end());
        }
        for (int t = 0; t < 512 && possible.size() <= 512 && candidates.size() < 32; t++) {
            int x = rng() % N;
            int y = rng() % N;
            if (lit[x][y] || candId[x][y] != -1) {
                continue;
            }
            for (int i = possible.size() - 1; i >= 0; i--) {
                possible.push_back(possible[i] | 1 << candidates.size());
            }
            candId[x][y] = candidates.size();
            candidates.push_back({x, y});
        }
        
        std::vector<std::array<int, 2>> query;
        int E = 1E9;
        for (int t = 0; t < 64; t++) {
            int p = rng() % 100 + 1;
            std::vector<std::array<int, 2>> q;
            for (auto [a, b, c] : determined) {
                if (rng() % 100 < p) {
                    q.push_back({a, b});
                }
            }
            for (auto [a, b] : candidates) {
                if (rng() % 100 < p) {
                    q.push_back({a, b});
                }
            }
            std::map<int, int> freq;
            for (auto s : possible) {
                freq[calc(q, s)]++;
            }
            int ent = 0;
            for (auto [_, c] : freq) {
                ent += c * c;
            }
            if (ent < E) {
                E = ent;
                query = q;
            }
        }
        
        int result;
        if (debug) {
            std::vector<bool> row(N), col(N);
            for (auto [x, y] : query) {
                if (lights[x][y] == 'H') {
                    row[x] = true;
                } else {
                    col[y] = true;
                }
            }
            result = N * N - std::count(row.begin(), row.end(), false) * std::count(col.begin(), col.end(), false);
            std::cerr << result << "\n";
        } else {
            std::cout << "?\n";
            
            std::vector choose(N, std::vector<bool>(N));
            for (auto [a, b] : query) {
                choose[a][b] = true;
            }
            
            for (int i = 0; i < N; i++) {
                for (int j = 0; j < N; j++) {
                    std::cout << choose[i][j];
                }
                std::cout << "\n";
            }
            std::cout.flush();
            
            std::cin >> result;
        }
        
        {
            std::vector<int> newPossible;
            for (auto s : possible) {
                if (debug) {
                    std::cerr << s << " expected : " << calc(query, s) << "\n";
                }
                if (calc(query, s) == result) {
                    newPossible.push_back(s);
                }
            }
            possible = std::move(newPossible);
        }
        
        int maybe[2] {};
        for (auto s : possible) {
            maybe[0] |= ((1 << candidates.size()) - 1) ^ s;
            maybe[1] |= s;
        }
        
        std::vector<std::array<int, 2>> newCand;
        for (int i = 0; i < candidates.size(); i++) {
            auto [x, y] = candidates[i];
            if ((maybe[0] ^ maybe[1]) >> i & 1) {
                if (!lit[x][y]) {
                    int t = maybe[0] >> i & 1 ? 0 : 1;
                    cnt[t]++;
                    type[x][y] = t;
                    if (t == 0) {
                        for (int j = 0; j < N; j++) {
                            lit[x][j] = true;
                        }
                    } else {
                        for (int j = 0; j < N; j++) {
                            lit[j][y] = true;
                        }
                    }
                    determined.push_back({x, y, t});
                }
                candId[x][y] = -1;
            } else {
                candId[x][y] = newCand.size();
                newCand.push_back({x, y});
            }
        }
        
        for (auto &s : possible) {
            int ns = 0;
            for (int i = 0; i < candidates.size(); i++) {
                if (s >> i & 1) {
                    auto [x, y] = candidates[i];
                    if (candId[x][y] != -1) {
                        ns |= 1 << candId[x][y];
                    }
                }
            }
            s = ns;
        }
        
        std::sort(possible.begin(), possible.end());
        possible.erase(std::unique(possible.begin(), possible.end()), possible.end());
        candidates = std::move(newCand);
    }
    
    int t = cnt[0] == N ? 0 : 1;
    std::cout << "!\n";
    
    std::vector choose(N, std::vector<bool>(N));
    for (auto [a, b, c] : determined) {
        if (c == t) {
            choose[a][b] = true;
        }
    }
    
    if (debug) {
        std::cout << "rounds : " << rounds << "\n";
    }
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            std::cout << choose[i][j];
        }
        std::cout << "\n";
    }
    std::cout.flush();
    
    return 0;
}

詳細信息

Subtask #1:

score: 11
Accepted

Test #1:

score: 11
Accepted
time: 3ms
memory: 3660kb

input:

3
6
3

output:

?
000
010
111
?
111
000
000
!
010
010
010

result:

points 1.0 points  1.0 correct, 2 queries

Test #2:

score: 11
Accepted
time: 4ms
memory: 3604kb

input:

3
9
9
9

output:

?
110
001
001
?
111
000
010
?
000
111
010
!
111
000
000

result:

points 1.0 points  1.0 correct, 3 queries

Test #3:

score: 11
Accepted
time: 4ms
memory: 3856kb

input:

3
9
9

output:

?
101
100
100
?
001
011
011
!
001
100
100

result:

points 1.0 points  1.0 correct, 2 queries

Test #4:

score: 11
Accepted
time: 4ms
memory: 3656kb

input:

3
7
7
8
8
7
7

output:

?
001
001
101
?
001
000
111
?
010
010
101
?
101
100
100
?
001
110
001
?
101
000
001
!
100
010
010

result:

points 1.0 points  1.0 correct, 6 queries

Test #5:

score: 11
Accepted
time: 4ms
memory: 3648kb

input:

3
7
5
7
8
9

output:

?
110
100
100
?
111
010
000
?
010
100
110
?
110
000
101
?
100
101
001
!
100
001
001

result:

points 1.0 points  1.0 correct, 5 queries

Test #6:

score: 11
Accepted
time: 4ms
memory: 3708kb

input:

3
7
9
5
6

output:

?
100
000
111
?
111
001
000
?
010
010
101
?
100
101
000
!
110
001
000

result:

points 1.0 points  1.0 correct, 4 queries

Test #7:

score: 11
Accepted
time: 2ms
memory: 3596kb

input:

3
7
6
8
8

output:

?
000
111
010
?
101
100
100
?
110
010
010
?
011
001
001
!
111
000
000

result:

points 1.0 points  1.0 correct, 4 queries

Test #8:

score: 11
Accepted
time: 3ms
memory: 3728kb

input:

3
6
9

output:

?
000
001
111
?
111
001
000
!
111
000
000

result:

points 1.0 points  1.0 correct, 2 queries

Test #9:

score: 11
Accepted
time: 4ms
memory: 3812kb

input:

3
8
7
6
7

output:

?
000
111
100
?
111
000
011
?
011
010
010
?
100
001
100
!
100
100
100

result:

points 1.0 points  1.0 correct, 4 queries

Test #10:

score: 11
Accepted
time: 4ms
memory: 3648kb

input:

3
8
7
9
9
7
8

output:

?
111
001
000
?
101
101
100
?
000
010
111
?
011
110
010
?
001
111
001
?
000
011
110
!
010
001
010

result:

points 1.0 points  1.0 correct, 6 queries

Test #11:

score: 11
Accepted
time: 4ms
memory: 3684kb

input:

3
7
7
9
9

output:

?
110
010
010
?
111
001
000
?
001
011
011
?
010
101
000
!
000
101
010

result:

points 1.0 points  1.0 correct, 4 queries

Test #12:

score: 11
Accepted
time: 4ms
memory: 3596kb

input:

3
9
8
9

output:

?
000
110
111
?
111
000
100
?
111
001
001
!
010
100
001

result:

points 1.0 points  1.0 correct, 3 queries

Test #13:

score: 11
Accepted
time: 5ms
memory: 3888kb

input:

3
7
7
5
5
7

output:

?
110
010
010
?
110
100
110
?
111
000
000
?
001
001
001
?
001
001
111
!
001
110
000

result:

points 1.0 points  1.0 correct, 5 queries

Test #14:

score: 11
Accepted
time: 5ms
memory: 3716kb

input:

3
7
9
8
7
7

output:

?
100
000
111
?
100
010
011
?
000
111
101
?
010
101
001
?
111
001
000
!
010
100
100

result:

points 1.0 points  1.0 correct, 5 queries

Test #15:

score: 11
Accepted
time: 2ms
memory: 3880kb

input:

3
7
8
8
6

output:

?
000
111
000
?
100
000
111
?
111
001
001
?
001
101
100
!
100
010
001

result:

points 1.0 points  1.0 correct, 4 queries

Test #16:

score: 11
Accepted
time: 4ms
memory: 3860kb

input:

3
9
5
5

output:

?
100
110
110
?
110
010
000
?
001
000
011
!
100
100
010

result:

points 1.0 points  1.0 correct, 3 queries

Test #17:

score: 11
Accepted
time: 4ms
memory: 3640kb

input:

3
9
9

output:

?
111
000
001
?
010
101
010
!
110
001
000

result:

points 1.0 points  1.0 correct, 2 queries

Subtask #2:

score: 11
Accepted

Dependency #1:

100%
Accepted

Test #18:

score: 11
Accepted
time: 3ms
memory: 3664kb

input:

3
6
6

output:

?
000
100
111
?
111
001
000
!
010
100
010

result:

points 1.0 points  1.0 correct, 2 queries

Test #19:

score: 11
Accepted
time: 3ms
memory: 3652kb

input:

3
9
9

output:

?
111
000
010
?
000
111
100
!
101
010
000

result:

points 1.0 points  1.0 correct, 2 queries

Test #20:

score: 11
Accepted
time: 4ms
memory: 3808kb

input:

3
7
8
8
7
7
6

output:

?
100
111
000
?
100
100
110
?
101
100
010
?
010
010
110
?
010
000
111
?
001
001
000
!
001
100
001

result:

points 1.0 points  1.0 correct, 6 queries

Test #21:

score: 11
Accepted
time: 4ms
memory: 3880kb

input:

3
8
8
5
7
9

output:

?
100
101
100
?
011
010
010
?
000
000
111
?
000
110
101
?
100
100
101
!
010
001
100

result:

points 1.0 points  1.0 correct, 5 queries

Test #22:

score: 11
Accepted
time: 5ms
memory: 3664kb

input:

3
7
7
7
7
5
7
9

output:

?
111
001
000
?
010
000
111
?
001
100
110
?
111
100
100
?
101
010
000
?
000
101
011
?
001
101
001
!
001
001
001

result:

points 1.0 points  1.0 correct, 7 queries

Test #23:

score: 11
Accepted
time: 4ms
memory: 3852kb

input:

3
7
9
9
9

output:

?
001
011
001
?
001
111
000
?
110
001
010
?
011
100
100
!
001
110
000

result:

points 1.0 points  1.0 correct, 4 queries

Test #24:

score: 11
Accepted
time: 3ms
memory: 3684kb

input:

3
8
7
9
7

output:

?
110
010
010
?
000
011
111
?
011
111
000
?
100
011
010
!
111
000
000

result:

points 1.0 points  1.0 correct, 4 queries

Test #25:

score: 11
Accepted
time: 3ms
memory: 3728kb

input:

3
6
9
5

output:

?
000
001
111
?
111
100
000
?
100
111
000
!
111
000
000

result:

points 1.0 points  1.0 correct, 3 queries

Test #26:

score: 11
Accepted
time: 3ms
memory: 3652kb

input:

3
6
9
7

output:

?
011
010
010
?
100
100
101
?
011
001
101
!
100
100
100

result:

points 1.0 points  1.0 correct, 3 queries

Test #27:

score: 11
Accepted
time: 4ms
memory: 3604kb

input:

3
8
9
9

output:

?
011
100
100
?
111
010
000
?
000
110
101
!
101
010
000

result:

points 1.0 points  1.0 correct, 3 queries

Test #28:

score: 11
Accepted
time: 5ms
memory: 3604kb

input:

3
7
7
8
7
9
5

output:

?
101
100
100
?
001
000
111
?
000
111
100
?
101
001
001
?
110
010
110
?
101
000
010
!
001
010
100

result:

points 1.0 points  1.0 correct, 6 queries

Test #29:

score: 11
Accepted
time: 4ms
memory: 3652kb

input:

3
7
8
9

output:

?
100
101
100
?
111
000
010
?
001
101
100
!
001
001
010

result:

points 1.0 points  1.0 correct, 3 queries

Test #30:

score: 11
Accepted
time: 4ms
memory: 3640kb

input:

3
8
7
9

output:

?
010
010
011
?
111
001
001
?
001
110
001
!
000
110
001

result:

points 1.0 points  1.0 correct, 3 queries

Test #31:

score: 11
Accepted
time: 5ms
memory: 3604kb

input:

3
7
7
7
8
9
5

output:

?
010
000
111
?
000
111
001
?
111
000
100
?
110
010
010
?
100
110
111
?
000
011
000
!
001
001
010

result:

points 1.0 points  1.0 correct, 6 queries

Test #32:

score: 11
Accepted
time: 0ms
memory: 3644kb

input:

3
9
9
8
9
9

output:

?
011
000
111
?
000
111
011
?
111
001
001
?
100
010
011
?
111
011
100
!
001
000
110

result:

points 1.0 points  1.0 correct, 5 queries

Test #33:

score: 11
Accepted
time: 4ms
memory: 3884kb

input:

3
7
7
8
7

output:

?
111
010
000
?
010
000
111
?
011
010
010
?
100
010
011
!
001
010
100

result:

points 1.0 points  1.0 correct, 4 queries

Test #34:

score: 11
Accepted
time: 4ms
memory: 3608kb

input:

3
8
7
8
7
7

output:

?
000
010
111
?
100
100
110
?
011
100
100
?
010
110
010
?
010
110
000
!
100
000
011

result:

points 1.0 points  1.0 correct, 5 queries

Test #35:

score: 11
Accepted
time: 19ms
memory: 3888kb

input:

10
50
100
60
90

output:

?
0000000000
0000000000
0000000000
1000000000
0000000000
0001100000
0100010001
0000000000
0000000110
1000000000
?
0100111000
0000000100
0010000010
1000000000
0000100010
0000100000
0100000000
1000000000
0000000010
1000000000
?
0100011000
0000000000
1010000010
1000000000
0000000010
0000000000
00000000...

result:

points 1.0 points  1.0 correct, 4 queries

Test #36:

score: 11
Accepted
time: 19ms
memory: 3660kb

input:

10
60
40
100

output:

?
0000100000
0000000010
0000000000
0000000000
0000000000
0100000000
0000000000
1100000000
1001001000
0000100000
?
0000100000
0000000001
0000000000
0000000000
0000000000
0100000000
0100000000
1000000000
1000000000
0000100000
?
0011110010
0000000011
0000000000
0000001000
0000000000
0000000000
00000000...

result:

points 1.0 points  1.0 correct, 3 queries

Test #37:

score: 11
Accepted
time: 30ms
memory: 3668kb

input:

10
64
82
64
100
86

output:

?
0000000000
0000000000
1000000000
1000000000
1000000000
0000000001
1000000000
0001000100
1000000100
0000000000
?
0000010000
0000000000
1000010000
1000000010
1000000000
0000000001
0001000000
0001000100
1001000100
0000000000
?
0000010000
0000000000
0000010000
1000000010
1000001100
0000000000
11010000...

result:

points 1.0 points  1.0 correct, 5 queries

Test #38:

score: 11
Accepted
time: 29ms
memory: 3656kb

input:

10
73
58
91
92
86
92
79

output:

?
0000100010
0010000000
0000001001
0000000000
0000000000
0100000100
0000000001
0000000100
0000000000
0000000001
?
0100000010
1000000000
0000001001
0000000000
0000000000
0101000100
0010000001
0000000000
0000000000
0000100000
?
0100100010
1010000000
0000000010
0000000000
0000001000
1100000000
00100000...

result:

points 1.0 points  1.0 correct, 7 queries

Test #39:

score: 11
Accepted
time: 58ms
memory: 3696kb

input:

10
65
72
72
76
58
76
95
90
86
90
93
58

output:

?
1000000001
0000001000
0000000000
1000001000
0000000000
0010000000
1000000000
0000000000
0000000001
0100001000
?
0000000001
0000001000
0000000000
0000001000
0000000000
0010000000
1000000000
0000010000
0000000001
0100001001
?
1000000000
0000000000
0001000000
1000001001
0000000000
0010000000
10000000...

result:

points 1.0 points  1.0 correct, 12 queries

Test #40:

score: 11
Accepted
time: 58ms
memory: 3864kb

input:

10
58
72
70
82
92
85
94
94
94
80
86

output:

?
0000000100
0010010100
0000010100
0000000000
0000000001
0000000001
0100000000
0000000000
0000000000
1000000000
?
0000000100
0000010100
0000010100
0000000000
0000000000
0000010001
0100000000
0000000100
0000000000
1000000000
?
1000001100
0000010000
0000110100
0000000100
0000000000
0000010000
00001000...

result:

points 1.0 points  1.0 correct, 11 queries

Test #41:

score: 11
Accepted
time: 30ms
memory: 3864kb

input:

8
43
46
64
57
50
34
43

output:

?
00000100
00010000
00001000
00010000
00001000
00001000
00000000
00110000
?
00000000
00010000
00000000
00010000
00101000
00001000
00010100
00010000
?
00000100
00010001
00001000
00010000
10101000
01000000
01010100
01000000
?
00000100
00010000
00000011
00000000
10000000
10000000
10010000
00100000
?
00...

result:

points 1.0 points  1.0 correct, 7 queries

Test #42:

score: 11
Accepted
time: 59ms
memory: 3888kb

input:

10
65
72
80
70
75
72
85
64
91
96
85
70

output:

?
0010000000
0000000000
0000000000
0000000000
0000001000
0010000010
0001001001
0100000000
1000000000
1000000000
?
0000000000
0000000000
0000000000
0000000000
0000001000
0010000011
0001001001
0100000000
0000000000
1000000100
?
0000000010
0000000000
0000000000
0000000010
0010001000
0010000011
00010010...

result:

points 1.0 points  1.0 correct, 12 queries

Test #43:

score: 11
Accepted
time: 48ms
memory: 3632kb

input:

9
57
61
71
73
72
69
69
65
61
56

output:

?
000000000
000000000
000001000
000000110
110001001
000000000
000000000
000000000
000000010
?
000000000
000000000
000111000
000000110
010000001
000000000
000000000
000000001
110001000
?
000000000
000000000
000111000
000000100
100001001
000000000
010000001
000000000
110000010
?
000000000
000110000
00...

result:

points 1.0 points  1.0 correct, 10 queries

Test #44:

score: 11
Accepted
time: 29ms
memory: 3660kb

input:

10
68
72
80
92
58
76

output:

?
1110000100
0001100010
0000000000
0000000000
0000000000
1000000000
0010000000
0010000000
0000000000
0000000000
?
1110000100
0001100010
0000010000
0000000000
0000000000
0000000000
0001000000
0010000000
0000000010
0010000000
?
0100000000
0000000010
0000000000
0000000000
0000010100
1000000000
00110000...

result:

points 1.0 points  1.0 correct, 6 queries

Test #45:

score: 11
Accepted
time: 59ms
memory: 3660kb

input:

10
60
70
76
79
85
60
90
76
90
95
90
100
91

output:

?
0000000000
0000000000
0000010000
0000000000
0000000000
0000000000
0111000100
0000010000
0000100010
0000000000
?
0000000000
0000000010
0001010000
0010000100
0000000000
0000000000
0111000100
0000000000
0000100010
0000000000
?
0000001000
0000001010
0001010000
0010000100
0000000000
0000000000
01000001...

result:

points 1.0 points  1.0 correct, 13 queries

Test #46:

score: 11
Accepted
time: 40ms
memory: 3596kb

input:

10
64
64
72
70
84
85
86
90

output:

?
0000000101
0001000000
0000000000
0000000000
0000001000
1000000000
0000000100
0001000000
1000000000
0000010000
?
0000000101
0011000000
0000000010
0000000000
0000001000
1000100000
0000000100
0000000000
0000000000
0000010000
?
0000000000
0010000000
0100000010
0000000000
0001001000
1010100000
00000101...

result:

points 1.0 points  1.0 correct, 8 queries

Test #47:

score: 11
Accepted
time: 36ms
memory: 3860kb

input:

10
60
60
73
60
91
90
100

output:

?
0000000000
0000000000
0100000000
0000001000
0010000000
0000001000
0000000001
0000001000
0000100000
0000000011
?
0000000000
0100000000
0100000000
0000000000
0010000000
0000001000
0000000001
0000001010
0000001000
0000100001
?
0000000000
0100000000
0100000000
1000001000
1010000000
0000001000
00000000...

result:

points 1.0 points  1.0 correct, 7 queries

Test #48:

score: 11
Accepted
time: 42ms
memory: 3816kb

input:

10
68
68
64
82
76
82
73
92
88
68

output:

?
1010000000
0000100000
0010000000
0000000000
0000000000
0001000000
1000000000
0110000000
1000000000
0000000000
?
1010000000
0100100000
0000000000
0000000001
0000000000
0001000000
1100000100
0100000000
1000000000
0000000000
?
0010000000
0100000000
0000000000
0000100011
0000000000
0001000000
11000001...

result:

points 1.0 points  1.0 correct, 10 queries

Test #49:

score: 11
Accepted
time: 39ms
memory: 3612kb

input:

10
64
70
80
86
95
72
84
80

output:

?
0000000000
0000000000
0000000000
0000000100
0000000010
0010000000
0001000000
0101000001
1000000000
0011000000
?
0000000000
0000000000
0000001000
0000000000
0000000010
0010000000
0001000000
0001000000
1000000000
0011001000
?
0010001000
0000000000
0000001000
0000000000
0000001010
0010000000
00010010...

result:

points 1.0 points  1.0 correct, 8 queries

Test #50:

score: 11
Accepted
time: 44ms
memory: 3612kb

input:

10
64
60
73
82
93
82
72
96
94
70

output:

?
0001100000
0000000000
0100000000
0000100000
0000100000
0010000000
0000000000
0001000000
0000000000
0100011000
?
0000100000
0000000110
0000000000
0000100000
0000100000
0000000000
0000000000
0001000000
0000000000
0100011000
?
0001000000
0000000111
0000000100
0100100000
0100000000
0010000000
00000000...

result:

points 1.0 points  1.0 correct, 10 queries

Test #51:

score: 11
Accepted
time: 56ms
memory: 3740kb

input:

10
64
46
70
76
84
84
72
76
90
97

output:

?
0000000000
0000000000
0000000001
0000100100
0000000010
0000000000
0000000110
0000000000
0000011000
1000000010
?
0000000000
1000000000
0000000000
0010100100
0000000010
0000000000
0000000010
0000000000
0000000000
0000000010
?
0000000000
0000000000
0000000001
0010100101
0000000000
0000000000
00000001...

result:

points 1.0 points  1.0 correct, 10 queries

Test #52:

score: 11
Accepted
time: 53ms
memory: 3864kb

input:

10
73
68
84
84
92
82
60
86
84
96
94
92
88

output:

?
0000000000
1010000000
0000000000
0000000110
0000010000
0100000000
0000001100
0000000000
0000000000
0000000001
?
0000000000
1000000000
1000000000
0000000010
0100000000
0101000000
0000001100
0000000000
1000000000
1000000101
?
0000010000
1010000000
1000000001
0000000100
0100010000
0101000000
10000011...

result:

points 1.0 points  1.0 correct, 13 queries

Test #53:

score: 11
Accepted
time: 39ms
memory: 3692kb

input:

10
70
73
86
70
68
64
51
85
80
80

output:

?
0000000000
0000001100
0000000000
0000110000
1000000010
0001000010
0000000000
0000000010
0000000000
0000000000
?
0000000000
0000101100
0000000000
0000110000
1000000010
0001010011
0000000000
0000010000
0000000000
0000000000
?
0000000000
0000001001
0000000000
0010100000
1000000010
0001010001
00100000...

result:

points 1.0 points  1.0 correct, 10 queries

Test #54:

score: 11
Accepted
time: 69ms
memory: 3692kb

input:

10
68
64
82
88
88
88
96
76
86
76
80
100
65
75
79

output:

?
0000000001
0000000000
0100010000
1000000000
0000000000
0100000000
0100000000
0010000000
0000000010
0001000000
?
0000000001
0000000001
0000010000
0000000000
0000000000
0000000010
0100010000
0000000000
0000000010
0001000000
?
0000000001
0000100001
0100010000
0000000100
0000000000
0100000010
00000100...

result:

points 1.0 points  1.0 correct, 15 queries

Test #55:

score: 11
Accepted
time: 52ms
memory: 3668kb

input:

10
64
65
64
72
84
76
76
73
80
100
82
65
88
58

output:

?
0000000000
0000010000
0000000001
0011000000
0000001000
0000000001
0000001000
0000000000
0000000001
0000000010
?
0000000000
0000010000
0000000001
0010000000
0000001000
0000000001
0000010000
0000010000
0000000001
0000000011
?
0000000000
0000000001
0000000001
1000000000
0001001000
0000000000
00000110...

result:

points 1.0 points  1.0 correct, 14 queries

Test #56:

score: 11
Accepted
time: 23ms
memory: 3720kb

input:

10
70
70
90
90

output:

?
0000001000
0000000000
0000000010
0000100100
0000000000
0000010000
0000000000
0000010000
1000000000
0010010000
?
0000001000
0000000000
0000010000
0000100100
0000000000
0000010011
0000000000
0000010000
1000000000
0010010000
?
0000001000
0000000000
0000010010
0000100100
0000001000
0000010011
00000001...

result:

points 1.0 points  1.0 correct, 4 queries

Test #57:

score: 11
Accepted
time: 52ms
memory: 3728kb

input:

10
51
68
82
60
82
80
80
75
94
94
52

output:

?
0101100000
0000000000
1000000000
0000000000
0000000000
0000000000
0000010000
0000000000
0000010110
0000000000
?
0001000000
0000000000
1001000000
0000000000
0000010000
0000000000
0100010000
0000000000
0000010110
0000001000
?
0101100001
0000000000
1000000000
0000100000
0000010010
0000000000
01000100...

result:

points 1.0 points  1.0 correct, 11 queries

Test #58:

score: 11
Accepted
time: 48ms
memory: 3656kb

input:

10
72
70
80
65
79
76
82
88
92
84

output:

?
0000000000
0000000010
0010000000
1100010000
0000000000
0000001000
0000000101
0100100000
0000000000
0000000000
?
0010000010
0000000010
0010000000
1100000000
0000000000
0000001000
0000000101
0100000000
0000000000
0000000000
?
0010000010
0000000010
0010000000
1100010000
0000000000
0001001000
10000001...

result:

points 1.0 points  1.0 correct, 10 queries

Test #59:

score: 11
Accepted
time: 41ms
memory: 3656kb

input:

10
70
60
76
70
91
93
82
100

output:

?
0001000000
0010000000
0001000000
0000000000
0000001000
0000100100
0010000000
0100010000
0000000000
0000000010
?
0000000000
0010000000
0001000000
0000000000
0000001000
0000000100
0000000000
0100010010
0000000000
0000001010
?
0001000001
0010000000
0001000000
0010000000
0001001000
0000000100
00100000...

result:

points 1.0 points  1.0 correct, 8 queries

Test #60:

score: 11
Accepted
time: 58ms
memory: 3868kb

input:

10
68
55
70
64
88
94
93
88
88
75

output:

?
0000000000
1000100000
0000000000
0000100010
0000001000
0000001001
0000000000
0000001000
0100000000
0000000100
?
0000000000
1010000000
0000000000
0000100010
0000000000
0000001001
0000000000
0000000000
0110000000
0000000100
?
0000000001
1010101000
0000000000
0000100000
0000000010
0000001000
00000000...

result:

points 1.0 points  1.0 correct, 10 queries

Test #61:

score: 11
Accepted
time: 24ms
memory: 3608kb

input:

10
73
84
91
84
64

output:

?
0001000000
0000000000
0010000001
0100000000
0000010000
0010000000
0000100001
0000000000
0000001001
0000000000
?
0000000000
0000001000
0110000001
0100000000
0000010000
0010010000
0000000001
0000000000
1100001001
0010000000
?
0001000000
0000001000
0110000001
0000000000
0000010000
0010000000
00001000...

result:

points 1.0 points  1.0 correct, 5 queries

Test #62:

score: 11
Accepted
time: 36ms
memory: 3628kb

input:

10
76
64
65
68
92
58
84
84

output:

?
1100000000
0000110000
0010000000
0000000000
0001000010
0001000000
0000000100
0010000000
0000000000
0000000000
?
0100000000
0000010000
0011000000
0000000000
0001000000
0001000000
0000000100
0010000000
0000000000
0000001000
?
1000000010
0100100000
0011000000
0000000000
0000000010
0001000000
00000000...

result:

points 1.0 points  1.0 correct, 8 queries

Test #63:

score: 11
Accepted
time: 21ms
memory: 3608kb

input:

9
65
69
73
54

output:

?
000011000
100000000
000000000
000000011
001000000
000000000
000100000
000000001
000000001
?
000011000
110000000
000000000
000000011
000000000
100001000
000100100
000000000
000000100
?
000001000
100000001
010000000
000000001
001000000
100000000
000100000
000011001
000000101
?
000001000
000000001
00...

result:

points 1.0 points  1.0 correct, 4 queries

Test #64:

score: 11
Accepted
time: 28ms
memory: 3656kb

input:

9
46
53
67
74
73
74

output:

?
000000000
000000100
000000000
100011001
000010000
000000001
000001000
000000000
000000001
?
000000000
000000100
000000000
100011001
010010000
000000000
100001000
000000000
000000011
?
000000000
000000100
000010000
000001001
010010000
000000001
101001001
000000000
100000011
?
000000000
000000100
00...

result:

points 1.0 points  1.0 correct, 6 queries

Test #65:

score: 11
Accepted
time: 9ms
memory: 3860kb

input:

8
64
57
48

output:

?
00000000
00000000
00001000
10000000
01000100
00100010
00010101
00000000
?
00000100
00000100
00000000
10000101
01000100
00100110
00010000
00000100
?
00000100
00000100
00001100
10000000
00000000
00100010
00000101
00000000
!
00000000
00000000
00001000
10000000
01000000
00100010
00010101
00000000

result:

points 1.0 points  1.0 correct, 3 queries

Test #66:

score: 11
Accepted
time: 14ms
memory: 3664kb

input:

8
34
43
57

output:

?
00000000
00000000
00000000
00100010
00001000
00000100
01001001
10010000
?
00010000
00100010
10010001
00000000
00001000
00000000
00001000
00010000
?
00110000
00100001
00000000
00000010
01001000
01110000
00000001
00010000
!
00010000
00100000
00010000
00000010
01000000
01000000
00000001
00010000

result:

points 1.0 points  1.0 correct, 3 queries

Test #67:

score: 11
Accepted
time: 20ms
memory: 3724kb

input:

7
37
44
45
43
37
31

output:

?
1000100
0000000
1010000
0101001
1000000
0100000
0000100
?
0010100
0000000
1011000
0101001
1000000
0000000
0000000
?
1000000
0010000
0010010
0000001
1010000
0100010
0010100
?
0010000
0000000
1000010
0100001
0010000
0000010
0000100
?
0000010
0000000
0000010
0101001
1000010
0000000
0010010
?
0000010
...

result:

points 1.0 points  1.0 correct, 6 queries

Test #68:

score: 11
Accepted
time: 7ms
memory: 3588kb

input:

7
42
19
42

output:

?
0000000
1000100
0001000
1000000
1000000
0001100
1010000
?
1001111
0000000
0000000
0010000
0000000
0000000
0000000
?
0110101
1000000
0001000
0010000
1000000
0000000
1000000
!
0000100
1000000
0001000
1000000
1000000
0000100
1000000

result:

points 1.0 points  1.0 correct, 3 queries

Test #69:

score: 11
Accepted
time: 53ms
memory: 3892kb

input:

10
76
72
79
86
82
82
86
76
82
80
72
80

output:

?
0000100010
0000000000
0100000000
0000000010
1000000000
0100000000
0000001000
1000001000
0000000000
0010000000
?
0000110010
0000000000
0100000000
0000000010
0000100000
0000100000
0000000000
1000000000
0000000000
0010000000
?
0000110000
0000000000
0100000100
0000010000
1010000000
0000100001
00000010...

result:

points 1.0 points  1.0 correct, 12 queries

Test #70:

score: 11
Accepted
time: 36ms
memory: 3716kb

input:

10
73
93
82
72
92
90
85

output:

?
0000100000
0000000001
0010000000
0000010000
0001000000
0000000000
0000000000
0000000001
0010000000
0000110100
?
0000101000
0000000001
0010000010
0000000001
0001000000
0000000010
0001000000
0000000001
0010000000
0000110100
?
1000101000
0000000000
0000000010
0000010101
0001000000
0000110010
00010000...

result:

points 1.0 points  1.0 correct, 7 queries

Test #71:

score: 11
Accepted
time: 62ms
memory: 3660kb

input:

10
58
65
75
79
64
88
75
76
100
79
90
85
76
86

output:

?
0010000000
0000000000
0000000000
0001000000
0000000000
0001001100
0000010000
0100000010
0000010000
0000000010
?
0110000000
0000100000
0000000000
0001000000
0000000000
0100001100
0000000000
0000000010
0000000000
0000000010
?
0011000000
0000100000
0000000000
0001000000
0000000000
0101001110
00000100...

result:

points 1.0 points  1.0 correct, 14 queries

Test #72:

score: 11
Accepted
time: 30ms
memory: 3724kb

input:

10
72
84
64
70
79
60
65
88

output:

?
0100000000
0000000010
1000000000
0100000000
0000000000
0000000000
0110001010
0000000000
0000000000
0010010000
?
0100000000
0000000010
1000000000
0100000000
0000000000
0000001000
0000001010
0100010000
0000000000
0010010000
?
0100000000
0000000010
0000000001
0100000000
0000000000
0000000000
00100100...

result:

points 1.0 points  1.0 correct, 8 queries

Test #73:

score: 11
Accepted
time: 48ms
memory: 3816kb

input:

10
64
58
72
88
92
88
70
88
79

output:

?
0000010000
0100001010
0000000000
0000000001
0000000000
0000000100
0000001000
0100000100
0000010000
0000000000
?
0000010000
0000000010
0000000000
1000000001
0000000000
0000010000
0000001000
0100000100
0000010000
0000000000
?
0000010000
0101000010
0000000000
1000000000
0100000000
0000010100
00000100...

result:

points 1.0 points  1.0 correct, 9 queries

Test #74:

score: 11
Accepted
time: 45ms
memory: 3864kb

input:

10
65
64
65
86
76
72
86
80
72
88
72

output:

?
0000000010
0001000001
0000000000
0000001100
0000010000
0000000000
0000000000
0000000000
0010000000
0000101000
?
0000000010
0001000000
0000000100
0000001100
0001010000
0000000000
0000000000
0000000000
0010000000
0000001000
?
1000000000
0000000001
0000000100
0000001000
0001010000
0000000000
00000000...

result:

points 1.0 points  1.0 correct, 11 queries

Test #75:

score: 11
Accepted
time: 40ms
memory: 3688kb

input:

10
64
51
76
80
84
94
80
90
90
58
46
88

output:

?
0000000100
0010000000
0000100010
0000000000
0000000000
0000001010
0100100000
0000000000
0000001000
0100000000
?
0000000000
0010000001
0000100010
0000000000
0000000000
0000000010
0100000000
0001000000
0000000000
0100000000
?
0000000100
0010000001
0000100010
0000000010
0000000000
0000100010
00001000...

result:

points 1.0 points  1.0 correct, 12 queries

Test #76:

score: 11
Accepted
time: 28ms
memory: 3808kb

input:

5
19
22
21
19
23
16
25
17

output:

?
00010
11110
00011
00000
01010
?
10000
01111
00010
00010
01010
?
10010
01011
00001
00010
00010
?
10010
10000
00010
00010
11100
?
11010
00010
01101
01010
00010
?
00000
00100
00100
00000
00110
?
01100
01010
01001
11100
01000
?
11010
00000
00000
11100
00000
!
00100
00100
01000
01000
01000

result:

points 1.0 points  1.0 correct, 8 queries

Subtask #3:

score: 0
Time Limit Exceeded

Dependency #1:

100%
Accepted

Dependency #2:

100%
Accepted

Test #77:

score: 78
Accepted
time: 0ms
memory: 3884kb

input:

3
6
6

output:

?
000
111
001
?
001
000
111
!
001
001
001

result:

points 1.0 points  1.0 correct, 2 queries

Test #78:

score: 78
Accepted
time: 3ms
memory: 3656kb

input:

3
9
9
6

output:

?
001
111
000
?
111
001
001
?
101
101
101
!
000
111
000

result:

points 1.0 points  1.0 correct, 3 queries

Test #79:

score: 78
Accepted
time: 5ms
memory: 3872kb

input:

3
7
7
7
9
9

output:

?
010
000
111
?
000
111
100
?
111
001
000
?
001
110
001
?
010
100
101
!
001
100
001

result:

points 1.0 points  1.0 correct, 5 queries

Test #80:

score: 78
Accepted
time: 4ms
memory: 3592kb

input:

3
7
8
8
9

output:

?
000
100
111
?
010
010
101
?
110
001
010
?
100
100
010
!
100
100
010

result:

points 1.0 points  1.0 correct, 4 queries

Test #81:

score: 78
Accepted
time: 4ms
memory: 3556kb

input:

3
7
7
9
7
8
7

output:

?
000
111
100
?
011
100
100
?
001
101
001
?
100
110
100
?
010
101
010
?
001
100
001
!
001
001
001

result:

points 1.0 points  1.0 correct, 6 queries

Test #82:

score: 78
Accepted
time: 2ms
memory: 3588kb

input:

3
9
5
5
9

output:

?
100
011
100
?
100
100
100
?
000
000
111
?
101
010
010
!
100
011
000

result:

points 1.0 points  1.0 correct, 4 queries

Test #83:

score: 78
Accepted
time: 2ms
memory: 3652kb

input:

3
7
9
8
7

output:

?
010
111
000
?
111
010
000
?
010
010
101
?
110
111
000
!
111
000
000

result:

points 1.0 points  1.0 correct, 4 queries

Test #84:

score: 78
Accepted
time: 5ms
memory: 3592kb

input:

3
7
7
7
6
7
6

output:

?
100
100
110
?
001
101
001
?
010
010
011
?
000
100
111
?
110
101
000
?
011
000
000
!
111
000
000

result:

points 1.0 points  1.0 correct, 6 queries

Test #85:

score: 78
Accepted
time: 3ms
memory: 3584kb

input:

3
6
9
7

output:

?
001
001
011
?
110
100
100
?
110
011
010
!
100
100
100

result:

points 1.0 points  1.0 correct, 3 queries

Test #86:

score: 78
Accepted
time: 4ms
memory: 3876kb

input:

3
7
7
7
7
8
5

output:

?
100
100
101
?
111
000
000
?
011
001
001
?
001
101
011
?
001
001
111
?
000
010
010
!
101
010
000

result:

points 1.0 points  1.0 correct, 6 queries

Test #87:

score: 78
Accepted
time: 3ms
memory: 3652kb

input:

3
5
5
7
7

output:

?
010
000
111
?
111
000
010
?
000
111
000
?
010
110
000
!
010
101
000

result:

points 1.0 points  1.0 correct, 4 queries

Test #88:

score: 78
Accepted
time: 4ms
memory: 3732kb

input:

3
7
5
7
5
5
7

output:

?
100
100
011
?
010
010
010
?
111
010
000
?
100
101
000
?
000
000
101
?
000
110
110
!
001
001
100

result:

points 1.0 points  1.0 correct, 6 queries

Test #89:

score: 78
Accepted
time: 5ms
memory: 3600kb

input:

3
7
7
7
7
6
9

output:

?
001
001
101
?
100
000
111
?
111
000
100
?
100
100
100
?
000
110
000
?
100
001
011
!
100
001
100

result:

points 1.0 points  1.0 correct, 6 queries

Test #90:

score: 78
Accepted
time: 3ms
memory: 3652kb

input:

3
9
8
8
9

output:

?
001
001
101
?
010
010
111
?
111
100
001
?
010
110
010
!
001
001
010

result:

points 1.0 points  1.0 correct, 4 queries

Test #91:

score: 78
Accepted
time: 2ms
memory: 3688kb

input:

3
7
9
7
9
5

output:

?
111
001
000
?
111
100
100
?
101
001
001
?
101
000
111
?
000
110
100
!
000
001
110

result:

points 1.0 points  1.0 correct, 5 queries

Test #92:

score: 78
Accepted
time: 2ms
memory: 3608kb

input:

3
9
9

output:

?
011
001
001
?
100
001
110
!
100
001
001

result:

points 1.0 points  1.0 correct, 2 queries

Test #93:

score: 78
Accepted
time: 4ms
memory: 3700kb

input:

3
7
9
9
7
6
7

output:

?
001
101
001
?
000
110
111
?
010
111
000
?
100
100
110
?
110
000
010
?
110
000
100
!
010
100
001

result:

points 1.0 points  1.0 correct, 6 queries

Test #94:

score: 78
Accepted
time: 35ms
memory: 3820kb

input:

10
70
60
60
90
100
80
70

output:

?
0000100000
0000100000
1000000000
0100000000
0000000000
0000001000
0000000000
0000100011
0000000100
0000000000
?
0000110010
0000000000
1000000000
0100000010
0000000000
0000001000
0000000000
0000000101
0000000100
0000000000
?
0000110010
0100100000
0000100000
0100100010
0000000000
0000000000
00000000...

result:

points 1.0 points  1.0 correct, 7 queries

Test #95:

score: 78
Accepted
time: 28ms
memory: 3608kb

input:

10
60
50
90
60
50

output:

?
0000000000
0000000001
0000000010
0000000000
0010000000
0000000001
0011000000
0000001000
0000000000
0000100010
?
0000000000
0000000001
0000000010
0010000000
0010000000
0000100001
0010000000
0010001000
0000000000
0010000010
?
0000000000
0000000101
0000000000
1000000100
0000000000
1000110000
00110100...

result:

points 1.0 points  1.0 correct, 5 queries

Test #96:

score: 78
Accepted
time: 25ms
memory: 3632kb

input:

10
60
60
90
80
100

output:

?
0000000000
0001000000
0000000000
0000010000
0000000000
0001000000
0001000000
0000010000
0001001101
0000000000
?
1000000000
0001000000
0000000000
0100010000
0000000000
0000000000
1001010000
0000010000
0000001101
0000000000
?
0000000010
0001001000
0010000000
0100010000
0000000000
0001000000
10010100...

result:

points 1.0 points  1.0 correct, 5 queries

Test #97:

score: 78
Accepted
time: 46ms
memory: 3628kb

input:

10
58
58
76
76
82
84
37
76
93

output:

?
0010000010
0000000010
1000000000
0000000000
0100000000
0000000000
0000000000
0000100000
0001010000
0000001000
?
0010000011
0000000000
1000010000
0000000000
0000000000
0010000000
0000000000
0001100000
0001000000
0000001000
?
0000000010
0000000110
1000010000
0000000000
0100000000
0000000000
00000000...

result:

points 1.0 points  1.0 correct, 9 queries

Test #98:

score: 78
Accepted
time: 34ms
memory: 3816kb

input:

10
79
84
72
79
86
72

output:

?
0000001001
0000000000
0000101000
0000010000
0000000000
1000100000
0000000000
0000000001
0000000010
0001000000
?
0000011001
0000000000
0000100000
0010010000
0000000000
1000000100
0000000100
0000000001
0001000010
0010000000
?
0000000000
0000000100
0000001000
0010010000
0000000001
1000100110
00000000...

result:

points 1.0 points  1.0 correct, 6 queries

Test #99:

score: 78
Accepted
time: 33ms
memory: 3652kb

input:

10
65
60
60
84
86
96
84

output:

?
0000100000
0000000010
1100000000
0000000000
0000000000
1001000100
0001000000
0000100000
0000000000
0000000001
?
0000000000
0000000010
1000000000
0000000000
0000000000
1001000100
0001000000
1000100000
0000000000
0001000001
?
0000000000
0010000010
1100001000
0000000000
0000000000
0001000000
00010000...

result:

points 1.0 points  1.0 correct, 7 queries

Test #100:

score: 78
Accepted
time: 32ms
memory: 3628kb

input:

8
43
43
58
59
60
59
39
52
59

output:

?
00000000
00010000
00000000
10010000
00000100
00010000
00100101
00000000
?
00000000
10000000
00000000
10010000
00010000
01010101
00100001
00000000
?
00000000
10000000
00010001
10010001
00010100
01010100
00000001
00100100
?
00001000
00010000
00010000
00000001
00010000
01000101
00100101
10000100
?
00...

result:

points 1.0 points  1.0 correct, 9 queries

Test #101:

score: 78
Accepted
time: 45ms
memory: 3736kb

input:

10
70
70
65
79
88
84
65
94
85
88
55
92

output:

?
0000000010
0000000000
0000011000
0000000000
0000001010
0000000001
0100010000
0000010000
0000000000
0000001000
?
0000000010
1001000000
0000011000
0000000000
0000000010
0000000001
0000010000
0000010000
0000010000
0000001000
?
0000000010
1001000000
1000011000
1000000000
0000000010
0000000001
01000000...

result:

points 1.0 points  1.0 correct, 12 queries

Test #102:

score: 78
Accepted
time: 29ms
memory: 3668kb

input:

9
61
56
69
57
71
71
57
60

output:

?
110100001
000000000
010000000
000000000
001000001
000000000
000000000
000010001
000000010
?
110100000
000000011
000000000
000010000
001000000
000000000
000000000
000010000
000000010
?
100000001
000010000
010000000
000010000
000000001
000000000
000000010
000110001
000000000
?
000100000
000010010
00...

result:

points 1.0 points  1.0 correct, 8 queries

Test #103:

score: 78
Accepted
time: 51ms
memory: 3700kb

input:

10
68
73
52
72
90
86
85
70
76

output:

?
0000000001
0000100000
0001000100
0000000000
0001000000
0010000000
0000100000
1000000000
0010000001
0000000000
?
0000000000
0000000000
0001000000
0000000000
0001000000
0010000000
0001100000
1000000010
0010000001
0000000100
?
1000000001
0000000000
0010000100
0000000000
0001000000
0010000000
00000000...

result:

points 1.0 points  1.0 correct, 9 queries

Test #104:

score: 78
Accepted
time: 40ms
memory: 3608kb

input:

10
60
65
75
70
55
92
64
88
79
86

output:

?
0000000000
0000000000
0001100000
0000000100
0010000000
0000000000
1001001000
0010000000
0000000000
0010000000
?
0000000000
0000000000
0001100010
0000000100
0000000000
0000000000
1001001000
0010000000
0000000000
0010101000
?
0000000000
0000100000
0001100010
0000000100
0010000000
0000000000
00000010...

result:

points 1.0 points  1.0 correct, 10 queries

Test #105:

score: 78
Accepted
time: 51ms
memory: 3612kb

input:

10
60
64
76
82
82
84
84
82
76
60

output:

?
0000000000
0001010000
0001000000
0000001000
0000000100
0000000000
0001000000
0000010000
0000100001
0000000000
?
0000000000
0000010000
0001000000
0000001000
0000000100
0000000000
0101100100
0000010000
0000010001
0000000000
?
0000000010
0001000000
0001000000
0000001000
0000000100
0000000000
01011001...

result:

points 1.0 points  1.0 correct, 10 queries

Test #106:

score: 78
Accepted
time: 27ms
memory: 3884kb

input:

10
70
70
80
73
73

output:

?
1000000000
0010000000
0010000100
0000000000
1100000000
0000000000
0000100100
0000000000
0001001000
0000000000
?
1000000000
0000000000
0010000100
0000000000
0100000000
0000000000
0000100100
0100000000
0001001000
0000000000
?
0010000000
0010000000
0010000110
0000000000
1000000000
0000000000
00001001...

result:

points 1.0 points  1.0 correct, 5 queries

Test #107:

score: 78
Accepted
time: 29ms
memory: 3864kb

input:

10
50
82
93
76
64
76
75
100
84

output:

?
0000000000
0000000000
0000100000
0001001110
0000000000
0000000000
0001000001
0000011000
1000000000
0000000000
?
0000100000
0000000100
0000100000
0000000010
0000000000
0010101000
0000000001
0000010000
1000000000
0001110000
?
1000110000
0000000100
0000100000
0000000010
0000000011
0000101000
00000000...

result:

points 1.0 points  1.0 correct, 9 queries

Test #108:

score: 78
Accepted
time: 51ms
memory: 3664kb

input:

10
73
82
72
70
76
92
82
88
73
92
94
79

output:

?
0000000100
0000100000
0000000000
0000000100
1000000000
0100000000
0000000001
0000010001
0000000100
0000000000
?
0101000100
0010100010
0000000010
0000000010
1000100000
0100000000
0000000001
0000010001
0000000100
0000000000
?
0100000100
0010100010
0000000000
1000000110
0000100000
0000000000
00000000...

result:

points 1.0 points  1.0 correct, 12 queries

Test #109:

score: 78
Accepted
time: 47ms
memory: 3700kb

input:

10
68
76
73
85
94
86
86
86
92
82
94

output:

?
0000010000
1001000000
0000000000
0000000010
0000000010
0100000010
0000000100
0000000000
0010000000
0000000000
?
0000010000
1000000000
0000000000
1000000010
0000000010
0000010010
0000000100
0000000000
1010000000
0000000010
?
0000010000
1001010000
0000000000
1000000010
0010000010
0000010000
00000001...

result:

points 1.0 points  1.0 correct, 11 queries

Test #110:

score: 78
Accepted
time: 52ms
memory: 3716kb

input:

10
55
64
84
76
79
93
84
73
96
65
80

output:

?
0011000010
0010000000
0000000000
0000000000
1001000000
0010000000
0000000001
0000000000
0000010001
0000000000
?
0011000000
0010100000
0000000000
0000000000
1001000000
0110000000
0000000001
0000000000
0000000001
0001000010
?
0011001010
0010110000
0000000000
0010000000
1000000010
0110000000
00000000...

result:

points 1.0 points  1.0 correct, 11 queries

Test #111:

score: 78
Accepted
time: 36ms
memory: 3692kb

input:

10
55
55
60
82
90
60
86
96
88
100

output:

?
0001000000
0000000000
0000000001
0000000000
0000001000
1000000000
0000000101
0000000000
1100001001
0000000000
?
0001000100
0000000000
0000000001
0000000000
0000000000
0000000101
0000000101
0001000000
1100001000
0000000000
?
0001000000
0000000000
0000000000
0000000000
0000001010
0000000001
00000001...

result:

points 1.0 points  1.0 correct, 10 queries

Test #112:

score: 78
Accepted
time: 46ms
memory: 3740kb

input:

10
55
60
64
64
76
88
73
82
52
96
92

output:

?
0000000000
0000000000
0000001000
1000101000
0000000000
0000011000
0001000000
0000000000
0000000001
0000000000
?
0000000000
0000000000
1000001000
1000001000
0000000000
0000011000
0000101000
0000000001
0000000001
0000010010
?
0000000000
0000000000
1001000000
1000000000
0000000000
0000010000
00011010...

result:

points 1.0 points  1.0 correct, 11 queries

Test #113:

score: 78
Accepted
time: 52ms
memory: 3664kb

input:

10
60
68
64
76
84
86
92
84
91
90
82
96

output:

?
0011000001
1000000000
0001000000
0000000000
0000000000
0000000100
0000010001
0000000000
0000000000
0100000001
?
0011000001
1000000000
0001000010
0000000000
0000000000
0001000100
0000110001
0000000000
0000000000
0000000001
?
0001000000
0000000000
0001000010
0000101000
0001000000
0001000000
00000100...

result:

points 1.0 points  1.0 correct, 12 queries

Test #114:

score: 78
Accepted
time: 42ms
memory: 3596kb

input:

10
68
60
65
84
84
86
91
88
76
94

output:

?
0000000000
0000100100
0100010000
1000000000
0001001000
0000000000
0000100000
0001000000
0001000000
0000000000
?
0000000000
0000100100
0000010000
0001010000
0001001000
0000000000
0000100000
1001000000
0001000000
0000000000
?
0000001000
0000000100
0100010001
0001010000
0000001100
0000000000
00000000...

result:

points 1.0 points  1.0 correct, 10 queries

Test #115:

score: 78
Accepted
time: 33ms
memory: 3664kb

input:

10
82
76
82
84
88
79
88
65
92

output:

?
0000000010
1000000000
0000100000
0000100000
0001000000
1000000000
0000000000
0101000000
1000000000
0000010000
?
0010000000
1000000000
0000000010
0000100000
0101000000
1000000000
0000000000
0001000000
0000000000
0000000010
?
0010000010
0000000000
0000100010
0000100000
0100000000
1000000100
00000000...

result:

points 1.0 points  1.0 correct, 9 queries

Test #116:

score: 78
Accepted
time: 78ms
memory: 3608kb

input:

10
65
64
75
75
76
85
76
85
80
88
80
85
79
84
76
52

output:

?
0000000001
0000000000
0000010000
0010010000
0000000000
0000010000
0000100100
0000000001
0000000000
1000000000
?
0010010001
0000000000
0000010000
0000010000
0000000000
0000010000
0000100000
0000000001
0000010000
1000000000
?
0000010001
0100000000
0000010000
0010000000
1000000000
0000010000
00001011...

result:

points 1.0 points  1.0 correct, 16 queries

Test #117:

score: 78
Accepted
time: 70ms
memory: 3692kb

input:

10
65
51
70
64
75
70
85
91
85
76
80
85
82
72
94

output:

?
0100000100
0001000000
0000000000
0000100111
1000010000
0000000000
0000000000
0000000000
0100000000
0000000000
?
0000000100
0001000000
0000000000
0000000111
1000000000
0000000000
0000000100
0000000000
0100000000
0000000000
?
0100100100
0001000000
0000000100
0000000011
1000010000
0000000100
00000101...

result:

points 1.0 points  1.0 correct, 15 queries

Test #118:

score: 78
Accepted
time: 32ms
memory: 3608kb

input:

10
79
85
70
92
100
95
85
92

output:

?
0000000000
0100000000
0000100100
0000000000
0000000000
1000010000
0101000000
0010000000
0000100000
0001000000
?
1000010000
0100000100
0000100100
0100000000
0000000000
0000010000
0100000000
0010001000
0000100000
0001000000
?
1001000000
0100000100
0000000110
0000001000
0000000000
1000000000
00000000...

result:

points 1.0 points  1.0 correct, 8 queries

Test #119:

score: 78
Accepted
time: 45ms
memory: 3672kb

input:

10
58
64
85
80
91
85
96
96
70
85
84

output:

?
1000000000
0110000000
0100000000
0000100000
0000100100
1000000000
0000000001
0000000001
0000000000
0000000000
?
1000000100
0110000000
0100000000
0000100000
0000100000
1000000000
0000000000
0001000001
0000000000
0000000000
?
1000000101
0110000000
0100000000
0000000000
0001100100
1000000000
00100000...

result:

points 1.0 points  1.0 correct, 11 queries

Test #120:

score: 78
Accepted
time: 26ms
memory: 3720kb

input:

10
60
70
80
90
50

output:

?
0100100000
0000000000
1001000000
0000000000
0000001100
0000001000
0000000000
0000000000
0100000000
0110000000
?
0100000000
0000000000
0001000000
0000000000
0000001000
0000001000
0000000000
0110000000
0100000000
0100000000
?
0100000000
0010111101
1000000000
0100000000
0000000100
0000000000
00000000...

result:

points 1.0 points  1.0 correct, 5 queries

Test #121:

score: 78
Accepted
time: 46ms
memory: 3664kb

input:

10
70
60
82
82
82
84
93
86

output:

?
0000000000
0000000000
0000000000
0000110000
0000000100
1000000000
0000000110
1000000001
0100000000
0000000010
?
0000000000
0000000000
0000000000
0000100000
0000000100
1000000000
0100000110
0000000001
0000000000
0000000100
?
0000000010
0000000000
0000000000
0000110000
0000000000
0000000000
01100011...

result:

points 1.0 points  1.0 correct, 8 queries

Test #122:

score: 78
Accepted
time: 43ms
memory: 3884kb

input:

9
57
45
60
69
65
63
65
67
72

output:

?
001000001
000000000
000000000
001100000
000000000
010100000
001000000
000000001
000010010
?
001000001
000000000
000000010
001000000
000000000
010100000
001000000
000000001
000000010
?
001000000
000000000
000000000
000100000
000000000
010100001
001010100
001000001
000010010
?
001000001
000001100
00...

result:

points 1.0 points  1.0 correct, 9 queries

Test #123:

score: 78
Accepted
time: 9ms
memory: 3880kb

input:

9
72
73
41

output:

?
000000010
000010000
100000100
000010010
001000000
000000000
000010000
000100000
000001000
?
000000010
000010000
000000000
000000010
001000000
111111111
000010000
000100000
000001000
?
000000000
000010000
000000000
000000000
001000000
000011011
000010000
000000000
000000000
!
000000010
000010000
10...

result:

points 1.0 points  1.0 correct, 3 queries

Test #124:

score: 78
Accepted
time: 25ms
memory: 3600kb

input:

8
50
58
56
54
59
54
36

output:

?
10000111
00100000
01000000
00001000
00000000
00000000
00000000
00100000
?
00000111
01000000
01001000
00001000
00001001
00000001
00000000
11100000
?
00000010
00000000
01001100
00000000
00000001
00000001
00000000
11100010
?
10000100
01000000
01000100
00000000
00001001
00010001
00010000
01101000
?
10...

result:

points 1.0 points  1.0 correct, 7 queries

Test #125:

score: 78
Accepted
time: 24ms
memory: 3860kb

input:

8
46
52
64
54
40
49

output:

?
11000100
00100000
00100000
00001100
00000000
00100000
00100000
00000000
?
01000000
10000000
00100000
00001000
01000000
00100000
00100010
00000000
?
11000100
11110000
00000100
00000100
01000000
00100000
00100010
00000010
?
11000101
11010010
00100100
00001000
00000000
00000000
00001000
00000010
?
01...

result:

points 1.0 points  1.0 correct, 6 queries

Test #126:

score: 78
Accepted
time: 23ms
memory: 3812kb

input:

7
37
43
43
43
49
42

output:

?
0010000
0000001
0001000
0110000
0010100
0001000
0100100
?
0000100
1000001
0001000
0100000
0010100
0001000
0000100
?
0010000
0000000
0000000
0110000
0010100
1001101
0100000
?
0010010
0000001
0001110
0110000
0010110
0000001
0000010
?
0000100
1000101
0001010
0010000
0010100
1001100
0100100
?
0000010
...

result:

points 1.0 points  1.0 correct, 6 queries

Test #127:

score: 78
Accepted
time: 24ms
memory: 3884kb

input:

7
31
43
31
44
28

output:

?
0010000
0000000
0000000
0000000
0100010
0100000
1000011
?
0010010
0000010
0000001
0000000
0110010
0100001
1000011
?
0010010
0000000
0000000
0000000
1100000
0100001
1001111
?
0000010
0000000
0010001
0001010
1000010
0000001
0001100
?
0000000
0000000
0000001
0000100
1110010
0000000
0011110
!
0010000
...

result:

points 1.0 points  1.0 correct, 5 queries

Test #128:

score: 78
Accepted
time: 55ms
memory: 3660kb

input:

10
52
72
82
88
88
80
76
88
82
72
76
88
86

output:

?
0001000000
0000000001
0000000000
0000000100
0000000001
1000100000
0000000000
0000001100
0000000001
0000001000
?
0000001000
0000000101
0000000000
0000000101
1000000001
1001000000
0000000100
0000001100
0000000000
0000001000
?
0001001001
0000000101
0000000000
0000000101
1000000001
1000000000
00000001...

result:

points 1.0 points  1.0 correct, 13 queries

Test #129:

score: 78
Accepted
time: 26ms
memory: 3628kb

input:

10
60
76
86
79
64

output:

?
1000000000
0000001000
0000000000
0000011100
1000000000
0000000000
0000000001
1000000000
0000000000
0000010000
?
1000000100
0010001000
0000010000
0000000100
1000000000
0000000000
0000000000
1000000000
0000000000
0000010000
?
1000010100
0010001000
0000000000
0000111000
0000000000
1000000000
00000000...

result:

points 1.0 points  1.0 correct, 5 queries

Test #130:

score: 78
Accepted
time: 63ms
memory: 3608kb

input:

10
64
51
70
70
70
86
92
76
88
79
73

output:

?
0001000000
1000000000
1000000000
1000001000
0000010000
0000000000
0001000001
0001000100
0000000000
0000000000
?
0001000000
0001000000
1000000000
1000001000
0000010000
0000000000
0001000000
0001000000
0000000000
0000000000
?
0000000000
1001000000
1000000000
1000001000
0000000010
0000000000
00010000...

result:

points 1.0 points  1.0 correct, 11 queries

Test #131:

score: 78
Accepted
time: 49ms
memory: 3864kb

input:

10
65
65
86
68
88
86
65
88
86
73
88
97

output:

?
0000010000
0000001000
0100000000
0111000000
0000000000
0001000000
0000000000
0000010000
0100000000
0000000001
?
0000010000
0000001000
0000000000
0111000000
0000000000
0001000000
1000000000
0000000000
0100000000
1000000001
?
0000010100
0000001000
0100000000
0101000000
0000000000
0001000000
10000010...

result:

points 1.0 points  1.0 correct, 12 queries

Test #132:

score: 78
Accepted
time: 67ms
memory: 3664kb

input:

10
58
52
72
76
88
88
85
82
75
80
95
70
65
60

output:

?
0001000000
0000000000
0011010000
1010100000
0000001000
0000000000
0000000000
0010000000
0000000000
0001000000
?
0001000000
0000000000
0001000000
1010100000
0000000010
0000000000
0000000000
0000000000
0000000000
0001000010
?
0001000000
0000000000
0011000000
1010000000
0000001010
0000000000
00000000...

result:

points 1.0 points  1.0 correct, 14 queries

Test #133:

score: 78
Accepted
time: 66ms
memory: 3700kb

input:

10
64
58
64
76
58
76
76
76
94
73
85
88
90
44
76
88

output:

?
0000000000
0000000001
0000000000
0000000000
0000000000
0000010000
0010001000
1000000011
0000000100
0001001000
?
0000000000
0000000001
0000000000
0100000000
0000000000
0000010000
0010000000
1000000011
0000000000
1001001000
?
0000000000
0000000000
0000000000
0100000000
0000000000
0000010000
00100000...

result:

points 1.0 points  1.0 correct, 16 queries

Test #134:

score: 78
Accepted
time: 39ms
memory: 3608kb

input:

10
55
65
84
72
88
96
76
85
90
65
64
70

output:

?
0000000100
0000011001
0000000000
0000010100
0000100000
0000000000
0100010000
0000000000
0000000000
0000000001
?
0010000110
0000000000
0000000000
0000000100
0000100000
0001000000
0100010000
0000000000
0000000000
0101000011
?
0000000010
0000001000
0000000000
0000010100
0000100010
0001000000
01000100...

result:

points 1.0 points  1.0 correct, 12 queries

Test #135:

score: 78
Accepted
time: 219ms
memory: 3848kb

input:

100
1000
1900
2200
3100
4500
5300
6300
6700
7900
8500
9500
8200
6500

output:

?
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

result:

points 1.0 points  1.0 correct, 13 queries

Test #136:

score: 78
Accepted
time: 226ms
memory: 3720kb

input:

100
900
1800
2800
3200
3800
4900
5900
7100
7800
8500
9400
9400

output:

?
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

result:

points 1.0 points  1.0 correct, 12 queries

Test #137:

score: 78
Accepted
time: 469ms
memory: 3724kb

input:

100
991
1387
1572
1768
1670
1981
3268
3986
3042
2748
4585
2704
4585
3376
3420
5308
5257
5140
5728
5590
5230
7096
7334
8572
8452
8045
8470
8785
6694
7705
8320
6400
8672

output:

?
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000...

result:

points 1.0 points  1.0 correct, 33 queries

Test #138:

score: 78
Accepted
time: 602ms
memory: 3852kb

input:

100
880
785
979
1168
1540
1168
1728
1735
1640
2320
1882
3928
1830
3400
3630
4393
5041
3160
4449
5632
3702
4192
6388
6052
4171
6436
7314
5767
6480
7504
6514
6472
6781
8499
8174
9012
8890
5380
7504
8999

output:

?
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

result:

points 1.0 points  1.0 correct, 40 queries

Test #139:

score: 0
Time Limit Exceeded

input:

100
984
1082
1360
1278
1916
1822
1744
1822
1744
2800
2143
3266
2732
2292
4171
3970
3340
2386
4432
200
3770
3948
2932
4037
4060
2467
100
1658
4660
3859
3630
4060
3160
4780
2002
600
3192
4215
1936
2839
4192
694
496
1076
1264
4632
3903
199
2374
694
1830
3430
2480
3649
100
2095
4606
3192
4780
3681
1076
...

output:

?
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

result: