Overlap-Safe Memory Copy

You are given a byte buffer represented by an integer array memory. Copy length bytes starting at sourceStart into the range starting at destinationStart, then return the mutated buffer.
Source and destination ranges may overlap. The result must be the same as if the source bytes were first copied into a temporary buffer. Every array value is between 0 and 255.

Function
copyBytes(memory: int[], sourceStart: int, destinationStart: int, length: int) → int[]

Examples
Example 1
memory = [1,2,3,4,5]
sourceStart = 0
destinationStart = 2
length = 3
return = [1,2,1,2,3]
Backward copying preserves bytes 2 and 3 before they are overwritten.
Example 2
memory = [1,2,3,4,5]
sourceStart = 2
destinationStart = 0
length = 3
return = [3,4,5,4,5]

Constraints
0 <= memory.length <= 100000.
Both ranges are within the array.
0 <= length <= memory.length.

The trick is copy direction, which is exactly what memmove does. If destinationStart is greater than sourceStart and the ranges overlap, a forward loop overwrites source bytes before it reads them. Example 1 shows it: copying forward from index 0 to 2 would turn the buffer into [1,2,1,2,1]. So copy backward, from i = length-1 down to 0. Otherwise, copy forward. When destinationStart is less than sourceStart, forward is safe, as Example 2 shows. Equal starts mean nothing changes. The simplest safe alternative is slicing out the source range into a temp array first, then writing it. That's O(length) extra space, and it's fine for 100000 elements. The common pitfall is picking one direction for every case. Also check length = 0 and an empty memory array. If you blank during the live OA, StealthCoder can surface the direction check so you can sanity-test against both examples.

Memorize the pattern. If you can't, run StealthCoder. The proctor sees the IDE. They don't see what's behind it.