QOJ.ac

QOJ

IDProblemSubmitterResultTimeMemoryLanguageFile sizeSubmit timeJudge time
#196220#1422. AvgconzloiAC ✓1ms3736kbC++201.1kb2023-10-01 14:15:292023-10-01 14:15:30

Details

Tip: Click on the bar to expand more detailed information

Test #1:

score: 100
Accepted
time: 1ms
memory: 3420kb

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: 3392kb

input:

6 3

output:

-1

result:

ok ok, n = 6, k = 3

Test #3:

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

input:

2 2

output:

1
1 2

result:

ok ok, n = 2, k = 2

Test #4:

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

input:

3 3

output:

1
1 2 3

result:

ok ok, n = 3, k = 3

Test #5:

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

input:

12 6

output:

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

result:

ok ok, n = 12, k = 6

Test #6:

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

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: 3420kb

input:

100 10

output:

20
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
1 11 ...

result:

ok ok, n = 100, k = 10

Test #8:

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

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 101 1...

result:

ok ok, n = 961, k = 31

Test #9:

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

input:

864 18

output:

240
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 = 18

Test #10:

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

input:

864 72

output:

24
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 = 864, k = 72

Test #11:

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

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: 3448kb

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: 1ms
memory: 3416kb

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: 3500kb

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: 1ms
memory: 3468kb

input:

998 499

output:

-1

result:

ok ok, n = 998, k = 499

Test #16:

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

input:

998 2

output:

-1

result:

ok ok, n = 998, k = 2

Test #17:

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

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: 3472kb

input:

1000 2

output:

-1

result:

ok ok, n = 1000, k = 2

Test #19:

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

input:

1000 4

output:

-1

result:

ok ok, n = 1000, k = 4

Test #20:

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

input:

1000 5

output:

-1

result:

ok ok, n = 1000, k = 5

Test #21:

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

input:

1000 8

output:

-1

result:

ok ok, n = 1000, k = 8

Test #22:

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

input:

1000 10

output:

300
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 = 10

Test #23:

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

input:

1000 20

output:

150
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 = 20

Test #24:

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

input:

1000 25

output:

-1

result:

ok ok, n = 1000, k = 25

Test #25:

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

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 1...

result:

ok ok, n = 1000, k = 40

Test #26:

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

input:

1000 50

output:

60
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 = 50

Test #27:

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

input:

1000 100

output:

20
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 = 100

Test #28:

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

input:

1000 125

output:

-1

result:

ok ok, n = 1000, k = 125

Test #29:

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

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: 1ms
memory: 3388kb

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: 1ms
memory: 3456kb

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: 3448kb

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: 3444kb

input:

4 4

output:

1
1 2 3 4

result:

ok ok, n = 4, k = 4

Test #34:

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

input:

8 2

output:

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

result:

ok ok, n = 8, k = 2

Test #35:

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

input:

8 4

output:

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

result:

ok ok, n = 8, k = 4

Test #36:

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

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: 3472kb

input:

16 2

output:

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

result:

ok ok, n = 16, k = 2

Test #38:

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

input:

16 4

output:

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

result:

ok ok, n = 16, k = 4

Test #39:

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

input:

16 8

output:

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

result:

ok ok, n = 16, k = 8

Test #40:

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

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: 3432kb

input:

32 2

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 3
5 7
9 11
13 15
17 19
21 23
25 27
29 31
1 5
9 13
17 21
25 29
1 9
17 25
1 17
9 25
5 13
21 29
5 21
13 29
3 7
11 15
19 23
27 31
3 11
19 27
3 19
11 27
7 15
23 31
7 23
15 31
2 4
6 8
10 12
14 16
18 20
22 24
26 28
...

result:

ok ok, n = 32, k = 2

Test #42:

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

input:

32 4

output:

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

result:

ok ok, n = 32, k = 4

Test #43:

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

input:

32 8

output:

8
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 5 9 13 17 21 25 29
2 6 10 14 18 22 26 30
3 7 11 15 19 23 27 31
4 8 12 16 20 24 28 32

result:

ok ok, n = 32, k = 8

Test #44:

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

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 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31
2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32

result:

ok ok, n = 32, k = 16

Test #45:

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

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: 3468kb

input:

64 2

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
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 3
5 7
9 11
13 15
17 19
21 23
25 27
29 31
33 35
37 39
41 43
45 47
49 51
53 55
57 59
61 63
1 5
9 13
17 21
25 29
3...

result:

ok ok, n = 64, k = 2

Test #47:

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

input:

64 4

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
1 5 9 13
17 21 25 29
33 37 41 45
49 53 57 61
1 17 33 49
5 21 37 53
9 25 41 57
13 29 45 61
2 6 10 14
18 22 26 30
34...

result:

ok ok, n = 64, k = 4

Test #48:

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

input:

64 8

output:

16
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 9 17 25 33 41 49 57
2 10 18 26 34 42 50 58
3 11 19 27 35 43 51 59
4 12 20 28 36 44 52 60
5 13 21 29 37 45 53 61
...

result:

ok ok, n = 64, k = 8

Test #49:

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

input:

64 16

output:

8
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 5 9 13 17 21 25 29 33 37 41 45 49 53 57 61
2 6 10 14 18 22 26 30 34 38 42 46 50 54 58 62
3 7 11 15 19 23 27 31 35...

result:

ok ok, n = 64, k = 16

Test #50:

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

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 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 51 53 55 57 59 61 63
2 4 6 8 10 12 14 16 18 2...

result:

ok ok, n = 64, k = 32

Test #51:

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

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: 1ms
memory: 3596kb

input:

128 2

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
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 = 128, k = 2

Test #53:

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

input:

128 4

output:

128
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 = 128, k = 4

Test #54:

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

input:

128 8

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 1...

result:

ok ok, n = 128, k = 8

Test #55:

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

input:

128 16

output:

16
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 = 16

Test #56:

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

input:

128 32

output:

8
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 = 32

Test #57:

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

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 10...

result:

ok ok, n = 128, k = 64

Test #58:

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

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: 1ms
memory: 3572kb

input:

256 2

output:

1024
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 = 2

Test #60:

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

input:

256 4

output:

256
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 = 4

Test #61:

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

input:

256 8

output:

96
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 = 256, k = 8

Test #62:

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

input:

256 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
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 = 256, k = 16

Test #63:

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

input:

256 32

output:

16
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 = 256, k = 32

Test #64:

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

input:

256 64

output:

8
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 = 64

Test #65:

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

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: 1ms
memory: 3540kb

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: 3736kb

input:

512 2

output:

2304
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 = 2

Test #68:

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

input:

512 4

output:

640
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 = 4

Test #69:

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

input:

512 8

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
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 = 8

Test #70:

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

input:

512 16

output:

96
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 = 16

Test #71:

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

input:

512 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
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 = 32

Test #72:

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

input:

512 64

output:

16
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 = 64

Test #73:

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

input:

512 128

output:

8
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 = 128

Test #74:

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

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: 3476kb

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: 1ms
memory: 3436kb

input:

76 19

output:

-1

result:

ok ok, n = 76, k = 19

Test #77:

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

input:

573 3

output:

-1

result:

ok ok, n = 573, k = 3

Test #78:

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

input:

86 43

output:

-1

result:

ok ok, n = 86, k = 43

Test #79:

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

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: 1ms
memory: 3480kb

input:

240 12

output:

-1

result:

ok ok, n = 240, k = 12

Test #81:

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

input:

350 25

output:

-1

result:

ok ok, n = 350, k = 25

Test #82:

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

input:

30 6

output:

-1

result:

ok ok, n = 30, k = 6

Test #83:

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

input:

33 11

output:

-1

result:

ok ok, n = 33, k = 11

Test #84:

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

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: 3400kb

input:

114 6

output:

-1

result:

ok ok, n = 114, k = 6

Test #86:

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

input:

192 32

output:

-1

result:

ok ok, n = 192, k = 32

Test #87:

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

input:

650 26

output:

-1

result:

ok ok, n = 650, k = 26

Test #88:

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

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 3 5 7 9 11 13 15 17 19
2 4 6 8 10 12 14 16 18 20

result:

ok ok, n = 20, k = 10

Test #89:

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

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: 3424kb

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 10...

result:

ok ok, n = 108, k = 54

Test #91:

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

input:

704 176

output:

8
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 = 704, k = 176

Test #92:

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

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: 3472kb

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

result:

ok ok, n = 48, k = 24

Test #94:

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

input:

72 12

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
1 7 13 19 25 31 37 43 49 55 61 67
2 8 14 20 26 32 38 44 50 56 62 68
3 9 15 21 27 33 39 45 ...

result:

ok ok, n = 72, k = 12

Test #95:

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

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 4 7 10 13 16 19 22 25 28 31 34 37 40 43 46 49 52 55 58 61
2 5 8 11 14 17 20 23 26 29 32 35 38 41 44 47 50 53 56 59 6...

result:

ok ok, n = 63, k = 21

Test #96:

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

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: 3428kb

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: 3544kb

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 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 51 53 55 57 59 61 63 65 67
2 4 6 ...

result:

ok ok, n = 68, k = 34

Test #99:

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

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
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 = 896, k = 14

Test #100:

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

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: 1ms
memory: 3520kb

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: 1ms
memory: 3464kb

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
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 = 648, k = 24

Test #103:

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

input:

600 30

output:

60
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 = 600, k = 30

Test #104:

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

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 1...

result:

ok ok, n = 686, k = 98

Test #105:

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

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: 3488kb

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: 1ms
memory: 3496kb

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: 1ms
memory: 3436kb

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: 1ms
memory: 3452kb

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: 1ms
memory: 3484kb

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: 1ms
memory: 3432kb

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 1...

result:

ok ok, n = 722, k = 38

Test #112:

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

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: 1ms
memory: 3436kb

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: 3484kb

input:

576 96

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 = 576, k = 96
English 繁體中文 简体中文

Server Time: 2025-02-01 17:18:09 | OpenSource Project