QOJ.ac
QOJ
ID | Problem | Submitter | Result | Time | Memory | Language | File size | Submit time | Judge time |
---|---|---|---|---|---|---|---|---|---|
#589521 | #1422. Avg | Afterlife# | AC ✓ | 1ms | 3980kb | C++20 | 1.2kb | 2024-09-25 18:14:47 | 2024-09-25 18:14:48 |
Judging History
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