Have you run the code?
If you reverse the array
['d', 'r', 'a', 'h', ' ', 's', 'i', ' ', 's', 'c'] you get the desired result of
['c', 's', ' ', 'i', 's', ' ', 'h', 'a', 'r', 'd']. If you then reverse the words you get
['s', 'c', ' ', 's', 'i', ' ', 'd', 'r', 'a', 'h'], which is not what you want.
You can't get better than an $O(n)$ complexity for reversing an array of size $n$. If you want an explanation as to why this is the case, then we must be slightly more precise. Below I do the analysis for an easy to analyze implementation, not an inplace version. (The analysis is similar for an inplace version, and I think that you can work it out.)
Let's assume that the operations which have a cost are "reading a value from an array", "writing a value to an array", and "comparing two values". The input to our algorithm is an array
input of size $n$ and the output is an array
output also of size $n$, and we must ensure that when the algorithm terminates that
output[i] == input[n-i-1] where $0 \leq i \leq n$. (Take a minute and convince yourself that this is a correct description of the problem, and that the equality is correct for both even and odd values of $n$.) To make the analysis as simple as possible, we will assume that there is an array named
output of size $n$ just waiting for us, and that
output[i] == 0 for all $i < n$.
Therefore, any algorithm must assign to
output[i] the value
input[n-i-1] for all $n$ possible values of $i$, unless
input[n-i-1] == 0, in which case no assignment needs to be made, as the correct value is already present. So one possible implementation would loop through the $n$ different values of $i$ and check if
input[n-i-1] == 0 and continue when the condition was true and assign the value to
output[i] when the condition was false.
If the input array is $n$
0s then this implementation would perform exactly $2n$ operations, one operation to get the value at
input[n-i-1] and one operation to compare it to
0. However, if there are no values of
0 in the input, then there are exactly $3n$ operations performed, $2n$ of the operations are the same as before, but now there are $n$ assignments of the value to the correct position in the output array (here we assume we don't need to read the value from the input array again). More generally if
0 occurs $m$ times in the input then there are exactly $2n + m$ operations performed.
Now this part is important: if we don't check the value, but instead just do the assignment then there are always $2n$ operations, one to read from the input and one to write to the output. Checking the value each time to avoid an unnecessary copy does more work than not checking the value in the majority of cases. Since any algorithm which uses these operations must do at least this much work, you can't do better than $O(n)$ operations.
But what about other operations? For an inplace version you might consider an operation which swaps two values in the array
swap(i, j). Such an operation allows you to reverse the array in $n/2$ operations (for even $n$), which is still $O(n)$.