A test case enlighted me
Input:

1
100 2

Output:

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

I found it humorous that basically this entire problem is 1-indexed, and then I saw...

Test Case 0:

There are many clever solutions in the discussion, but they aren't exactly straightfoward to me, so I've worked out myself.

First, there are two exception cases, like below:

1.k == 0: print all the numbers from 1 to N

2.if (n / k) % 2 is not ZERO, print -1 (as this must be zero to be abolute permutation)

Otherwise, follow the pattern below:

if we go from 1 to N (i),

Permutation is either i+k or i-k. It always starts with i+k.

1.Put i+k to permutaion for k times

2.Switch to i-k for k times

• repeat 1 & 2 until the end.

my python3 solution is below:

t = int(input().strip())
for a0 in range(t):
    n,k = map(int, input().split(" "))
    
    if k == 0:
        print (*list(range(1, n+1)))
    elif (n/k) % 2 != 0:
        print ("-1")
    else:
        add = True
        perm = []
        
        for i in range(1, n+1):
            if add:
                perm.append(i+k)
                
            else:
                perm.append(i-k)
                
            if i % k == 0:
                if add:
                    add = False
                else:
                    add = True
        print (*perm)

Here are 3 things you may want to know if you are stuck:

-If n is an even number (n%k == 0) lets you know if there is a valid permutation or you should just print -1

-If k=0 just print 1... n

-If n is an odd number and it also is greater than 0, print -1

Here's an un-clever solution. It's still linear time but comes at the cost of an extra linear amount of overhead.

The gist is that we're going to be constructing our permutation one number at a time.

For the ith number in the permutation, we can choose (-K + i), (K + i), or neither. The value we choose has to be between 1 and N, as well as not already used in our permutation. Moreover, we should choose (-K + i) over (K + i) if both work*. If we ever encounter an iteration where neither choice is possible, we can stop as no such permutation is possible. If we can choose a number in each iteration, we'll end up with the required permutation.

*We should choose (-K + i) over (K + i) because we won't be seeing this value C = (-K + i) ever again in the coming iterations. Since K is given to be positive, (-K + i) <= (K + i). As we look at the choices for future numbers in the permutation, i increases. In turn, (-K + i) and (K + i) will increase further and further away from C. So if we don't choose C = (-K + i), our "permutation" will be missing that value and won't actually be a permutation of the correct set of 1 to N.

If you think about it, this means we don't have to worry about computing the lexicographically smallest permutation. There's only ever one correct choice to be made at each iteration.