QOJ.ac

QOJ

IDProblemSubmitterResultTimeMemoryLanguageFile sizeSubmit timeJudge time
#589521#1422. AvgAfterlife#AC ✓1ms3980kbC++201.2kb2024-09-25 18:14:472024-09-25 18:14:48

Judging History

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

  • [2024-09-25 18:14:48]
  • 评测
  • 测评结果:AC
  • 用时:1ms
  • 内存:3980kb
  • [2024-09-25 18:14:47]
  • 提交

answer

#include <bits/stdc++.h>
using namespace std;
    vector<vector<int> > ans;
    int k;
int f[1005];
int from[1005];
void solve(int l,int r) {
    if(r-l+1 == k) {
        vector<int> cur;
        for(int j = l;j <= r;j++) cur.push_back(j) ;
        ans.push_back(cur) ; return ;
    }
    int u = from[r - l + 1] ;
    int len = (r - l + 1) / u;
    for(int i = l ; i <= r ;i += len) {
        solve(i , i + len - 1);
    }
    for(int dl = 0 , dr;dl < len; dl = dr + 1) {
        vector<int> cur ;
        dr = dl + k/u - 1;
        for(int i = dl ; i <= dr ; i++) {
            for(int j = l + i ; j <= r ; j += len) cur.push_back(j);
        }
        ans.push_back(cur);
    }
    return ;
}
int main() {
    int n;cin >> n >> k;
    vector<int> v;
    for(int i = 2;i <= k;i++) {
        if(k % i == 0) v.push_back(i) ;
    }
    f[k] = 1;
    for(int i = k + 1;i <= n;i++) {
        for(auto u : v) {
            if(i % u == 0 && f[i / u]) {f[i] = 1 ; from[i] = u ; break ;}
        }
    }
    if(!f[n]) {
        cout << -1 ; return 0;
    }
    solve(1 , n);
    cout << ans.size() << '\n';
    for(auto v : ans) {
        for(auto x : v) cout << x <<' ' ;
        cout << '\n';
    }
}

Details

Tip: Click on the bar to expand more detailed information

Test #1:

score: 100
Accepted
time: 0ms
memory: 3616kb

input:

4 2

output:

4
1 2 
3 4 
1 3 
2 4 

result:

ok ok, n = 4, k = 2

Test #2:

score: 0
Accepted
time: 0ms
memory: 3528kb

input:

6 3

output:

-1

result:

ok ok, n = 6, k = 3

Test #3:

score: 0
Accepted
time: 0ms
memory: 3612kb

input:

2 2

output:

1
1 2 

result:

ok ok, n = 2, k = 2

Test #4:

score: 0
Accepted
time: 0ms
memory: 3552kb

input:

3 3

output:

1
1 2 3 

result:

ok ok, n = 3, k = 3

Test #5:

score: 0
Accepted
time: 0ms
memory: 3776kb

input:

12 6

output:

4
1 2 3 4 5 6 
7 8 9 10 11 12 
1 7 2 8 3 9 
4 10 5 11 6 12 

result:

ok ok, n = 12, k = 6

Test #6:

score: 0
Accepted
time: 0ms
memory: 3616kb

input:

25 5

output:

10
1 2 3 4 5 
6 7 8 9 10 
11 12 13 14 15 
16 17 18 19 20 
21 22 23 24 25 
1 6 11 16 21 
2 7 12 17 22 
3 8 13 18 23 
4 9 14 19 24 
5 10 15 20 25 

result:

ok ok, n = 25, k = 5

Test #7:

score: 0
Accepted
time: 0ms
memory: 3560kb

input:

100 10

output:

30
1 2 3 4 5 6 7 8 9 10 
11 12 13 14 15 16 17 18 19 20 
21 22 23 24 25 26 27 28 29 30 
31 32 33 34 35 36 37 38 39 40 
41 42 43 44 45 46 47 48 49 50 
1 11 21 31 41 2 12 22 32 42 
3 13 23 33 43 4 14 24 34 44 
5 15 25 35 45 6 16 26 36 46 
7 17 27 37 47 8 18 28 38 48 
9 19 29 39 49 10 20 30 40 50 
51 52...

result:

ok ok, n = 100, k = 10

Test #8:

score: 0
Accepted
time: 0ms
memory: 3792kb

input:

961 31

output:

62
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 
32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 
63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 
94 95 96 97 98 99 100 10...

result:

ok ok, n = 961, k = 31

Test #9:

score: 0
Accepted
time: 1ms
memory: 3852kb

input:

864 18

output:

288
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 
19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 
37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 
1 19 37 2 20 38 3 21 39 4 22 40 5 23 41 6 24 42 
7 25 43 8 26 44 9 27 45 10 28 46 11 29 47 12 30 48 
13 31 49 14 32 50 15 33 51 16 34 52 17 ...

result:

ok ok, n = 864, k = 18

Test #10:

score: 0
Accepted
time: 1ms
memory: 3636kb

input:

864 72

output:

48
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 
73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 ...

result:

ok ok, n = 864, k = 72

Test #11:

score: 0
Accepted
time: 0ms
memory: 3624kb

input:

210 210

output:

1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 10...

result:

ok ok, n = 210, k = 210

Test #12:

score: 0
Accepted
time: 0ms
memory: 3564kb

input:

572 286

output:

4
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 10...

result:

ok ok, n = 572, k = 286

Test #13:

score: 0
Accepted
time: 0ms
memory: 3624kb

input:

997 997

output:

1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 10...

result:

ok ok, n = 997, k = 997

Test #14:

score: 0
Accepted
time: 0ms
memory: 3628kb

input:

998 998

output:

1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 10...

result:

ok ok, n = 998, k = 998

Test #15:

score: 0
Accepted
time: 0ms
memory: 3624kb

input:

998 499

output:

-1

result:

ok ok, n = 998, k = 499

Test #16:

score: 0
Accepted
time: 0ms
memory: 3616kb

input:

998 2

output:

-1

result:

ok ok, n = 998, k = 2

Test #17:

score: 0
Accepted
time: 0ms
memory: 3864kb

input:

964 482

output:

4
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 10...

result:

ok ok, n = 964, k = 482

Test #18:

score: 0
Accepted
time: 0ms
memory: 3620kb

input:

1000 2

output:

-1

result:

ok ok, n = 1000, k = 2

Test #19:

score: 0
Accepted
time: 0ms
memory: 3548kb

input:

1000 4

output:

-1

result:

ok ok, n = 1000, k = 4

Test #20:

score: 0
Accepted
time: 0ms
memory: 3532kb

input:

1000 5

output:

-1

result:

ok ok, n = 1000, k = 5

Test #21:

score: 0
Accepted
time: 0ms
memory: 3812kb

input:

1000 8

output:

-1

result:

ok ok, n = 1000, k = 8

Test #22:

score: 0
Accepted
time: 1ms
memory: 3556kb

input:

1000 10

output:

500
1 2 3 4 5 6 7 8 9 10 
11 12 13 14 15 16 17 18 19 20 
21 22 23 24 25 26 27 28 29 30 
31 32 33 34 35 36 37 38 39 40 
41 42 43 44 45 46 47 48 49 50 
1 11 21 31 41 2 12 22 32 42 
3 13 23 33 43 4 14 24 34 44 
5 15 25 35 45 6 16 26 36 46 
7 17 27 37 47 8 18 28 38 48 
9 19 29 39 49 10 20 30 40 50 
51 5...

result:

ok ok, n = 1000, k = 10

Test #23:

score: 0
Accepted
time: 1ms
memory: 3880kb

input:

1000 20

output:

200
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 
21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 
61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 
81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 ...

result:

ok ok, n = 1000, k = 20

Test #24:

score: 0
Accepted
time: 0ms
memory: 3784kb

input:

1000 25

output:

-1

result:

ok ok, n = 1000, k = 25

Test #25:

score: 0
Accepted
time: 1ms
memory: 3824kb

input:

1000 40

output:

75
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 
81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101...

result:

ok ok, n = 1000, k = 40

Test #26:

score: 0
Accepted
time: 1ms
memory: 3640kb

input:

1000 50

output:

80
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 
101...

result:

ok ok, n = 1000, k = 50

Test #27:

score: 0
Accepted
time: 0ms
memory: 3792kb

input:

1000 100

output:

30
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 
101 ...

result:

ok ok, n = 1000, k = 100

Test #28:

score: 0
Accepted
time: 0ms
memory: 3448kb

input:

1000 125

output:

-1

result:

ok ok, n = 1000, k = 125

Test #29:

score: 0
Accepted
time: 0ms
memory: 3664kb

input:

1000 200

output:

10
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 1...

result:

ok ok, n = 1000, k = 200

Test #30:

score: 0
Accepted
time: 0ms
memory: 3516kb

input:

1000 250

output:

12
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 1...

result:

ok ok, n = 1000, k = 250

Test #31:

score: 0
Accepted
time: 0ms
memory: 3560kb

input:

1000 500

output:

4
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 10...

result:

ok ok, n = 1000, k = 500

Test #32:

score: 0
Accepted
time: 0ms
memory: 3600kb

input:

1000 1000

output:

1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 10...

result:

ok ok, n = 1000, k = 1000

Test #33:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

4 4

output:

1
1 2 3 4 

result:

ok ok, n = 4, k = 4

Test #34:

score: 0
Accepted
time: 0ms
memory: 3592kb

input:

8 2

output:

12
1 2 
3 4 
1 3 
2 4 
5 6 
7 8 
5 7 
6 8 
1 5 
2 6 
3 7 
4 8 

result:

ok ok, n = 8, k = 2

Test #35:

score: 0
Accepted
time: 0ms
memory: 3548kb

input:

8 4

output:

4
1 2 3 4 
5 6 7 8 
1 5 2 6 
3 7 4 8 

result:

ok ok, n = 8, k = 4

Test #36:

score: 0
Accepted
time: 0ms
memory: 3588kb

input:

8 8

output:

1
1 2 3 4 5 6 7 8 

result:

ok ok, n = 8, k = 8

Test #37:

score: 0
Accepted
time: 0ms
memory: 3852kb

input:

16 2

output:

32
1 2 
3 4 
1 3 
2 4 
5 6 
7 8 
5 7 
6 8 
1 5 
2 6 
3 7 
4 8 
9 10 
11 12 
9 11 
10 12 
13 14 
15 16 
13 15 
14 16 
9 13 
10 14 
11 15 
12 16 
1 9 
2 10 
3 11 
4 12 
5 13 
6 14 
7 15 
8 16 

result:

ok ok, n = 16, k = 2

Test #38:

score: 0
Accepted
time: 0ms
memory: 3652kb

input:

16 4

output:

12
1 2 3 4 
5 6 7 8 
1 5 2 6 
3 7 4 8 
9 10 11 12 
13 14 15 16 
9 13 10 14 
11 15 12 16 
1 9 2 10 
3 11 4 12 
5 13 6 14 
7 15 8 16 

result:

ok ok, n = 16, k = 4

Test #39:

score: 0
Accepted
time: 0ms
memory: 3852kb

input:

16 8

output:

4
1 2 3 4 5 6 7 8 
9 10 11 12 13 14 15 16 
1 9 2 10 3 11 4 12 
5 13 6 14 7 15 8 16 

result:

ok ok, n = 16, k = 8

Test #40:

score: 0
Accepted
time: 0ms
memory: 3656kb

input:

16 16

output:

1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 

result:

ok ok, n = 16, k = 16

Test #41:

score: 0
Accepted
time: 0ms
memory: 3596kb

input:

32 2

output:

80
1 2 
3 4 
1 3 
2 4 
5 6 
7 8 
5 7 
6 8 
1 5 
2 6 
3 7 
4 8 
9 10 
11 12 
9 11 
10 12 
13 14 
15 16 
13 15 
14 16 
9 13 
10 14 
11 15 
12 16 
1 9 
2 10 
3 11 
4 12 
5 13 
6 14 
7 15 
8 16 
17 18 
19 20 
17 19 
18 20 
21 22 
23 24 
21 23 
22 24 
17 21 
18 22 
19 23 
20 24 
25 26 
27 28 
25 27 
26 2...

result:

ok ok, n = 32, k = 2

Test #42:

score: 0
Accepted
time: 0ms
memory: 3840kb

input:

32 4

output:

32
1 2 3 4 
5 6 7 8 
1 5 2 6 
3 7 4 8 
9 10 11 12 
13 14 15 16 
9 13 10 14 
11 15 12 16 
1 9 2 10 
3 11 4 12 
5 13 6 14 
7 15 8 16 
17 18 19 20 
21 22 23 24 
17 21 18 22 
19 23 20 24 
25 26 27 28 
29 30 31 32 
25 29 26 30 
27 31 28 32 
17 25 18 26 
19 27 20 28 
21 29 22 30 
23 31 24 32 
1 17 2 18 
3...

result:

ok ok, n = 32, k = 4

Test #43:

score: 0
Accepted
time: 0ms
memory: 3620kb

input:

32 8

output:

12
1 2 3 4 5 6 7 8 
9 10 11 12 13 14 15 16 
1 9 2 10 3 11 4 12 
5 13 6 14 7 15 8 16 
17 18 19 20 21 22 23 24 
25 26 27 28 29 30 31 32 
17 25 18 26 19 27 20 28 
21 29 22 30 23 31 24 32 
1 17 2 18 3 19 4 20 
5 21 6 22 7 23 8 24 
9 25 10 26 11 27 12 28 
13 29 14 30 15 31 16 32 

result:

ok ok, n = 32, k = 8

Test #44:

score: 0
Accepted
time: 0ms
memory: 3620kb

input:

32 16

output:

4
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 
17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 
1 17 2 18 3 19 4 20 5 21 6 22 7 23 8 24 
9 25 10 26 11 27 12 28 13 29 14 30 15 31 16 32 

result:

ok ok, n = 32, k = 16

Test #45:

score: 0
Accepted
time: 0ms
memory: 3616kb

input:

32 32

output:

1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 

result:

ok ok, n = 32, k = 32

Test #46:

score: 0
Accepted
time: 0ms
memory: 3788kb

input:

64 2

output:

192
1 2 
3 4 
1 3 
2 4 
5 6 
7 8 
5 7 
6 8 
1 5 
2 6 
3 7 
4 8 
9 10 
11 12 
9 11 
10 12 
13 14 
15 16 
13 15 
14 16 
9 13 
10 14 
11 15 
12 16 
1 9 
2 10 
3 11 
4 12 
5 13 
6 14 
7 15 
8 16 
17 18 
19 20 
17 19 
18 20 
21 22 
23 24 
21 23 
22 24 
17 21 
18 22 
19 23 
20 24 
25 26 
27 28 
25 27 
26 ...

result:

ok ok, n = 64, k = 2

Test #47:

score: 0
Accepted
time: 0ms
memory: 3660kb

input:

64 4

output:

80
1 2 3 4 
5 6 7 8 
1 5 2 6 
3 7 4 8 
9 10 11 12 
13 14 15 16 
9 13 10 14 
11 15 12 16 
1 9 2 10 
3 11 4 12 
5 13 6 14 
7 15 8 16 
17 18 19 20 
21 22 23 24 
17 21 18 22 
19 23 20 24 
25 26 27 28 
29 30 31 32 
25 29 26 30 
27 31 28 32 
17 25 18 26 
19 27 20 28 
21 29 22 30 
23 31 24 32 
1 17 2 18 
3...

result:

ok ok, n = 64, k = 4

Test #48:

score: 0
Accepted
time: 0ms
memory: 3656kb

input:

64 8

output:

32
1 2 3 4 5 6 7 8 
9 10 11 12 13 14 15 16 
1 9 2 10 3 11 4 12 
5 13 6 14 7 15 8 16 
17 18 19 20 21 22 23 24 
25 26 27 28 29 30 31 32 
17 25 18 26 19 27 20 28 
21 29 22 30 23 31 24 32 
1 17 2 18 3 19 4 20 
5 21 6 22 7 23 8 24 
9 25 10 26 11 27 12 28 
13 29 14 30 15 31 16 32 
33 34 35 36 37 38 39 40 ...

result:

ok ok, n = 64, k = 8

Test #49:

score: 0
Accepted
time: 0ms
memory: 3612kb

input:

64 16

output:

12
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 
17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 
1 17 2 18 3 19 4 20 5 21 6 22 7 23 8 24 
9 25 10 26 11 27 12 28 13 29 14 30 15 31 16 32 
33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 
49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 
33 49 34 50 35 51 36 ...

result:

ok ok, n = 64, k = 16

Test #50:

score: 0
Accepted
time: 0ms
memory: 3556kb

input:

64 32

output:

4
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 
33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 
1 33 2 34 3 35 4 36 5 37 6 38 7 39 8 40 9 41 10 42 11 43 12 44 13 45 14 46 15 47 16 48 
17 49 18 50 19 51 20 52 2...

result:

ok ok, n = 64, k = 32

Test #51:

score: 0
Accepted
time: 0ms
memory: 3552kb

input:

64 64

output:

1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 

result:

ok ok, n = 64, k = 64

Test #52:

score: 0
Accepted
time: 0ms
memory: 3640kb

input:

128 2

output:

448
1 2 
3 4 
1 3 
2 4 
5 6 
7 8 
5 7 
6 8 
1 5 
2 6 
3 7 
4 8 
9 10 
11 12 
9 11 
10 12 
13 14 
15 16 
13 15 
14 16 
9 13 
10 14 
11 15 
12 16 
1 9 
2 10 
3 11 
4 12 
5 13 
6 14 
7 15 
8 16 
17 18 
19 20 
17 19 
18 20 
21 22 
23 24 
21 23 
22 24 
17 21 
18 22 
19 23 
20 24 
25 26 
27 28 
25 27 
26 ...

result:

ok ok, n = 128, k = 2

Test #53:

score: 0
Accepted
time: 0ms
memory: 3508kb

input:

128 4

output:

192
1 2 3 4 
5 6 7 8 
1 5 2 6 
3 7 4 8 
9 10 11 12 
13 14 15 16 
9 13 10 14 
11 15 12 16 
1 9 2 10 
3 11 4 12 
5 13 6 14 
7 15 8 16 
17 18 19 20 
21 22 23 24 
17 21 18 22 
19 23 20 24 
25 26 27 28 
29 30 31 32 
25 29 26 30 
27 31 28 32 
17 25 18 26 
19 27 20 28 
21 29 22 30 
23 31 24 32 
1 17 2 18 
...

result:

ok ok, n = 128, k = 4

Test #54:

score: 0
Accepted
time: 0ms
memory: 3852kb

input:

128 8

output:

80
1 2 3 4 5 6 7 8 
9 10 11 12 13 14 15 16 
1 9 2 10 3 11 4 12 
5 13 6 14 7 15 8 16 
17 18 19 20 21 22 23 24 
25 26 27 28 29 30 31 32 
17 25 18 26 19 27 20 28 
21 29 22 30 23 31 24 32 
1 17 2 18 3 19 4 20 
5 21 6 22 7 23 8 24 
9 25 10 26 11 27 12 28 
13 29 14 30 15 31 16 32 
33 34 35 36 37 38 39 40 ...

result:

ok ok, n = 128, k = 8

Test #55:

score: 0
Accepted
time: 0ms
memory: 3556kb

input:

128 16

output:

32
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 
17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 
1 17 2 18 3 19 4 20 5 21 6 22 7 23 8 24 
9 25 10 26 11 27 12 28 13 29 14 30 15 31 16 32 
33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 
49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 
33 49 34 50 35 51 36 ...

result:

ok ok, n = 128, k = 16

Test #56:

score: 0
Accepted
time: 0ms
memory: 3848kb

input:

128 32

output:

12
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 
33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 
1 33 2 34 3 35 4 36 5 37 6 38 7 39 8 40 9 41 10 42 11 43 12 44 13 45 14 46 15 47 16 48 
17 49 18 50 19 51 20 52 ...

result:

ok ok, n = 128, k = 32

Test #57:

score: 0
Accepted
time: 0ms
memory: 3852kb

input:

128 64

output:

4
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 
65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 1...

result:

ok ok, n = 128, k = 64

Test #58:

score: 0
Accepted
time: 0ms
memory: 3620kb

input:

128 128

output:

1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 10...

result:

ok ok, n = 128, k = 128

Test #59:

score: 0
Accepted
time: 0ms
memory: 3708kb

input:

256 2

output:

1024
1 2 
3 4 
1 3 
2 4 
5 6 
7 8 
5 7 
6 8 
1 5 
2 6 
3 7 
4 8 
9 10 
11 12 
9 11 
10 12 
13 14 
15 16 
13 15 
14 16 
9 13 
10 14 
11 15 
12 16 
1 9 
2 10 
3 11 
4 12 
5 13 
6 14 
7 15 
8 16 
17 18 
19 20 
17 19 
18 20 
21 22 
23 24 
21 23 
22 24 
17 21 
18 22 
19 23 
20 24 
25 26 
27 28 
25 27 
26...

result:

ok ok, n = 256, k = 2

Test #60:

score: 0
Accepted
time: 0ms
memory: 3580kb

input:

256 4

output:

448
1 2 3 4 
5 6 7 8 
1 5 2 6 
3 7 4 8 
9 10 11 12 
13 14 15 16 
9 13 10 14 
11 15 12 16 
1 9 2 10 
3 11 4 12 
5 13 6 14 
7 15 8 16 
17 18 19 20 
21 22 23 24 
17 21 18 22 
19 23 20 24 
25 26 27 28 
29 30 31 32 
25 29 26 30 
27 31 28 32 
17 25 18 26 
19 27 20 28 
21 29 22 30 
23 31 24 32 
1 17 2 18 
...

result:

ok ok, n = 256, k = 4

Test #61:

score: 0
Accepted
time: 0ms
memory: 3792kb

input:

256 8

output:

192
1 2 3 4 5 6 7 8 
9 10 11 12 13 14 15 16 
1 9 2 10 3 11 4 12 
5 13 6 14 7 15 8 16 
17 18 19 20 21 22 23 24 
25 26 27 28 29 30 31 32 
17 25 18 26 19 27 20 28 
21 29 22 30 23 31 24 32 
1 17 2 18 3 19 4 20 
5 21 6 22 7 23 8 24 
9 25 10 26 11 27 12 28 
13 29 14 30 15 31 16 32 
33 34 35 36 37 38 39 40...

result:

ok ok, n = 256, k = 8

Test #62:

score: 0
Accepted
time: 0ms
memory: 3824kb

input:

256 16

output:

80
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 
17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 
1 17 2 18 3 19 4 20 5 21 6 22 7 23 8 24 
9 25 10 26 11 27 12 28 13 29 14 30 15 31 16 32 
33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 
49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 
33 49 34 50 35 51 36 ...

result:

ok ok, n = 256, k = 16

Test #63:

score: 0
Accepted
time: 0ms
memory: 3560kb

input:

256 32

output:

32
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 
33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 
1 33 2 34 3 35 4 36 5 37 6 38 7 39 8 40 9 41 10 42 11 43 12 44 13 45 14 46 15 47 16 48 
17 49 18 50 19 51 20 52 ...

result:

ok ok, n = 256, k = 32

Test #64:

score: 0
Accepted
time: 0ms
memory: 3652kb

input:

256 64

output:

12
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 
65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 ...

result:

ok ok, n = 256, k = 64

Test #65:

score: 0
Accepted
time: 0ms
memory: 3652kb

input:

256 128

output:

4
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 10...

result:

ok ok, n = 256, k = 128

Test #66:

score: 0
Accepted
time: 0ms
memory: 3504kb

input:

256 256

output:

1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 10...

result:

ok ok, n = 256, k = 256

Test #67:

score: 0
Accepted
time: 1ms
memory: 3980kb

input:

512 2

output:

2304
1 2 
3 4 
1 3 
2 4 
5 6 
7 8 
5 7 
6 8 
1 5 
2 6 
3 7 
4 8 
9 10 
11 12 
9 11 
10 12 
13 14 
15 16 
13 15 
14 16 
9 13 
10 14 
11 15 
12 16 
1 9 
2 10 
3 11 
4 12 
5 13 
6 14 
7 15 
8 16 
17 18 
19 20 
17 19 
18 20 
21 22 
23 24 
21 23 
22 24 
17 21 
18 22 
19 23 
20 24 
25 26 
27 28 
25 27 
26...

result:

ok ok, n = 512, k = 2

Test #68:

score: 0
Accepted
time: 1ms
memory: 3668kb

input:

512 4

output:

1024
1 2 3 4 
5 6 7 8 
1 5 2 6 
3 7 4 8 
9 10 11 12 
13 14 15 16 
9 13 10 14 
11 15 12 16 
1 9 2 10 
3 11 4 12 
5 13 6 14 
7 15 8 16 
17 18 19 20 
21 22 23 24 
17 21 18 22 
19 23 20 24 
25 26 27 28 
29 30 31 32 
25 29 26 30 
27 31 28 32 
17 25 18 26 
19 27 20 28 
21 29 22 30 
23 31 24 32 
1 17 2 18 ...

result:

ok ok, n = 512, k = 4

Test #69:

score: 0
Accepted
time: 1ms
memory: 3688kb

input:

512 8

output:

448
1 2 3 4 5 6 7 8 
9 10 11 12 13 14 15 16 
1 9 2 10 3 11 4 12 
5 13 6 14 7 15 8 16 
17 18 19 20 21 22 23 24 
25 26 27 28 29 30 31 32 
17 25 18 26 19 27 20 28 
21 29 22 30 23 31 24 32 
1 17 2 18 3 19 4 20 
5 21 6 22 7 23 8 24 
9 25 10 26 11 27 12 28 
13 29 14 30 15 31 16 32 
33 34 35 36 37 38 39 40...

result:

ok ok, n = 512, k = 8

Test #70:

score: 0
Accepted
time: 0ms
memory: 3576kb

input:

512 16

output:

192
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 
17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 
1 17 2 18 3 19 4 20 5 21 6 22 7 23 8 24 
9 25 10 26 11 27 12 28 13 29 14 30 15 31 16 32 
33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 
49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 
33 49 34 50 35 51 36...

result:

ok ok, n = 512, k = 16

Test #71:

score: 0
Accepted
time: 0ms
memory: 3572kb

input:

512 32

output:

80
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 
33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 
1 33 2 34 3 35 4 36 5 37 6 38 7 39 8 40 9 41 10 42 11 43 12 44 13 45 14 46 15 47 16 48 
17 49 18 50 19 51 20 52 ...

result:

ok ok, n = 512, k = 32

Test #72:

score: 0
Accepted
time: 0ms
memory: 3784kb

input:

512 64

output:

32
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 
65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 ...

result:

ok ok, n = 512, k = 64

Test #73:

score: 0
Accepted
time: 0ms
memory: 3504kb

input:

512 128

output:

12
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 1...

result:

ok ok, n = 512, k = 128

Test #74:

score: 0
Accepted
time: 0ms
memory: 3504kb

input:

512 256

output:

4
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 10...

result:

ok ok, n = 512, k = 256

Test #75:

score: 0
Accepted
time: 0ms
memory: 3860kb

input:

512 512

output:

1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 10...

result:

ok ok, n = 512, k = 512

Test #76:

score: 0
Accepted
time: 0ms
memory: 3528kb

input:

76 19

output:

-1

result:

ok ok, n = 76, k = 19

Test #77:

score: 0
Accepted
time: 0ms
memory: 3552kb

input:

573 3

output:

-1

result:

ok ok, n = 573, k = 3

Test #78:

score: 0
Accepted
time: 0ms
memory: 3812kb

input:

86 43

output:

-1

result:

ok ok, n = 86, k = 43

Test #79:

score: 0
Accepted
time: 0ms
memory: 3812kb

input:

44 44

output:

1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 

result:

ok ok, n = 44, k = 44

Test #80:

score: 0
Accepted
time: 0ms
memory: 3500kb

input:

240 12

output:

-1

result:

ok ok, n = 240, k = 12

Test #81:

score: 0
Accepted
time: 0ms
memory: 3620kb

input:

350 25

output:

-1

result:

ok ok, n = 350, k = 25

Test #82:

score: 0
Accepted
time: 0ms
memory: 3780kb

input:

30 6

output:

-1

result:

ok ok, n = 30, k = 6

Test #83:

score: 0
Accepted
time: 0ms
memory: 3784kb

input:

33 11

output:

-1

result:

ok ok, n = 33, k = 11

Test #84:

score: 0
Accepted
time: 0ms
memory: 3620kb

input:

5 5

output:

1
1 2 3 4 5 

result:

ok ok, n = 5, k = 5

Test #85:

score: 0
Accepted
time: 0ms
memory: 3616kb

input:

114 6

output:

-1

result:

ok ok, n = 114, k = 6

Test #86:

score: 0
Accepted
time: 0ms
memory: 3556kb

input:

192 32

output:

-1

result:

ok ok, n = 192, k = 32

Test #87:

score: 0
Accepted
time: 0ms
memory: 3556kb

input:

650 26

output:

-1

result:

ok ok, n = 650, k = 26

Test #88:

score: 0
Accepted
time: 0ms
memory: 3560kb

input:

20 10

output:

4
1 2 3 4 5 6 7 8 9 10 
11 12 13 14 15 16 17 18 19 20 
1 11 2 12 3 13 4 14 5 15 
6 16 7 17 8 18 9 19 10 20 

result:

ok ok, n = 20, k = 10

Test #89:

score: 0
Accepted
time: 0ms
memory: 3568kb

input:

963 321

output:

6
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 10...

result:

ok ok, n = 963, k = 321

Test #90:

score: 0
Accepted
time: 0ms
memory: 3500kb

input:

108 54

output:

4
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 1...

result:

ok ok, n = 108, k = 54

Test #91:

score: 0
Accepted
time: 0ms
memory: 3624kb

input:

704 176

output:

12
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 1...

result:

ok ok, n = 704, k = 176

Test #92:

score: 0
Accepted
time: 0ms
memory: 3496kb

input:

846 282

output:

6
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 10...

result:

ok ok, n = 846, k = 282

Test #93:

score: 0
Accepted
time: 0ms
memory: 3620kb

input:

48 24

output:

4
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 
25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 
1 25 2 26 3 27 4 28 5 29 6 30 7 31 8 32 9 33 10 34 11 35 12 36 
13 37 14 38 15 39 16 40 17 41 18 42 19 43 20 44 21 45 22 46 23 47 24 48 

result:

ok ok, n = 48, k = 24

Test #94:

score: 0
Accepted
time: 0ms
memory: 3552kb

input:

72 12

output:

18
1 2 3 4 5 6 7 8 9 10 11 12 
13 14 15 16 17 18 19 20 21 22 23 24 
25 26 27 28 29 30 31 32 33 34 35 36 
1 13 25 2 14 26 3 15 27 4 16 28 
5 17 29 6 18 30 7 19 31 8 20 32 
9 21 33 10 22 34 11 23 35 12 24 36 
37 38 39 40 41 42 43 44 45 46 47 48 
49 50 51 52 53 54 55 56 57 58 59 60 
61 62 63 64 65 66 6...

result:

ok ok, n = 72, k = 12

Test #95:

score: 0
Accepted
time: 0ms
memory: 3496kb

input:

63 21

output:

6
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 
43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 
1 22 43 2 23 44 3 24 45 4 25 46 5 26 47 6 27 48 7 28 49 
8 29 50 9 30 51 10 31 52 11 32 53 12 33 54 13 34 55 14 35 ...

result:

ok ok, n = 63, k = 21

Test #96:

score: 0
Accepted
time: 0ms
memory: 3628kb

input:

702 234

output:

6
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 10...

result:

ok ok, n = 702, k = 234

Test #97:

score: 0
Accepted
time: 0ms
memory: 3596kb

input:

423 141

output:

6
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 10...

result:

ok ok, n = 423, k = 141

Test #98:

score: 0
Accepted
time: 0ms
memory: 3812kb

input:

68 34

output:

4
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 
35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 
1 35 2 36 3 37 4 38 5 39 6 40 7 41 8 42 9 43 10 44 11 45 12 46 13 47 14 48 15 49 16 50 17 51 
18 52 1...

result:

ok ok, n = 68, k = 34

Test #99:

score: 0
Accepted
time: 1ms
memory: 3892kb

input:

896 14

output:

448
1 2 3 4 5 6 7 8 9 10 11 12 13 14 
15 16 17 18 19 20 21 22 23 24 25 26 27 28 
1 15 2 16 3 17 4 18 5 19 6 20 7 21 
8 22 9 23 10 24 11 25 12 26 13 27 14 28 
29 30 31 32 33 34 35 36 37 38 39 40 41 42 
43 44 45 46 47 48 49 50 51 52 53 54 55 56 
29 43 30 44 31 45 32 46 33 47 34 48 35 49 
36 50 37 51 3...

result:

ok ok, n = 896, k = 14

Test #100:

score: 0
Accepted
time: 0ms
memory: 3564kb

input:

960 480

output:

4
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 10...

result:

ok ok, n = 960, k = 480

Test #101:

score: 0
Accepted
time: 0ms
memory: 3564kb

input:

640 320

output:

4
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 10...

result:

ok ok, n = 640, k = 320

Test #102:

score: 0
Accepted
time: 0ms
memory: 3792kb

input:

648 24

output:

108
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 
25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 
49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 
1 25 49 2 26 50 3 27 51 4 28 52 5 29 53 6 30 54 7 31 55 8 32 56 
9 33 57 10 34 58 11 3...

result:

ok ok, n = 648, k = 24

Test #103:

score: 0
Accepted
time: 1ms
memory: 3568kb

input:

600 30

output:

80
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 
31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 
61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 
91 92 93 94 95 96 97 98 99 100 10...

result:

ok ok, n = 600, k = 30

Test #104:

score: 0
Accepted
time: 0ms
memory: 3628kb

input:

686 98

output:

14
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 
99 100 101 ...

result:

ok ok, n = 686, k = 98

Test #105:

score: 0
Accepted
time: 0ms
memory: 3628kb

input:

596 298

output:

4
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 10...

result:

ok ok, n = 596, k = 298

Test #106:

score: 0
Accepted
time: 0ms
memory: 3616kb

input:

524 262

output:

4
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 10...

result:

ok ok, n = 524, k = 262

Test #107:

score: 0
Accepted
time: 0ms
memory: 3632kb

input:

928 464

output:

4
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 10...

result:

ok ok, n = 928, k = 464

Test #108:

score: 0
Accepted
time: 0ms
memory: 3560kb

input:

652 326

output:

4
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 10...

result:

ok ok, n = 652, k = 326

Test #109:

score: 0
Accepted
time: 0ms
memory: 3628kb

input:

688 344

output:

4
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 10...

result:

ok ok, n = 688, k = 344

Test #110:

score: 0
Accepted
time: 0ms
memory: 3492kb

input:

884 442

output:

4
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 10...

result:

ok ok, n = 884, k = 442

Test #111:

score: 0
Accepted
time: 0ms
memory: 3660kb

input:

722 38

output:

38
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 
39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 
77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101...

result:

ok ok, n = 722, k = 38

Test #112:

score: 0
Accepted
time: 0ms
memory: 3616kb

input:

920 460

output:

4
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 10...

result:

ok ok, n = 920, k = 460

Test #113:

score: 0
Accepted
time: 0ms
memory: 3600kb

input:

956 478

output:

4
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 10...

result:

ok ok, n = 956, k = 478

Test #114:

score: 0
Accepted
time: 0ms
memory: 3624kb

input:

576 96

output:

18
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 
97 98 99 100 101 ...

result:

ok ok, n = 576, k = 96