"Ease the Array" challenge
This is a decent start. Here are some things that could be improved.
Naming
Your variable names are single letters that as far as I can tell have no relationship to what they represent. The variable x is the number of test cases to run. You should name it numTestCases or testCases. q is the specific test case you're currently running, so testCase or testCaseIndex would be a better name. n is the number of inputs to read, so numInputs would be a good name. And arr tells us very little other than that it is an array. How about inputs? I would rename i to inputIndex, as it's for iterating over the inputs. d could be outputIndex.
Functions
There are 4 different things your code does:

Reads the inputs from the user (or stdin)
Finds duplicate items in the array and combines them
Moves 0s to the end of the array
Prints the results

Each of those should be a different function with a clear name.
Space Efficiency
You have an array declared as int arr[100000]. Assuming a typical 32-bit int implementation, that's ~400k. On my system, the default stack size is 1MB. That means that single array takes up half the stack. If had just two more of those, you'd get a stack overflow just running the app. Since it's only 1 allocation at the start of the program and not a repeating allocation, I recommend using malloc() to allocate the array and freeing it after you've finished.
Time Efficiency
The main slowdown in your code is the part that copies the remaining elements when you find a 0 in the array. There are built-in functions in the standard library to do this task for you. In this case, this loop:
            for(m=0;k+m+1&lt;=j;m++)
            {
                arr[k+m]=arr[k+m+1];
            }

can be replaced with a single line:
            memmove(&amp;arr[k], &amp;arr[k+1], sizeof(arr[0]) * (j - (k + 1) + 1));

This is significantly more efficient. The library function (which is sometimes not even a function), can use SIMD instructions, and other speedups to make it much faster than you're likely to do on your own. And it's portable. When I run the test with just that single change, it passes.
There are other ways you could speed this up, too. Instead of copying the remaining portion of the array at every 0, you could read up to the first 0. Mark that index. Read up to the next 0. Move only the values between those 2 indexes back, and repeat. This way you never move any element in the array more than once.