Implement core puzzle/array/grid routines

You may need to complete one or more of the coding exercises below (produce clean, testable code; explain the time and space complexity):

1. Jigsaw assembly (small backtracking)

• You receive N square tiles. Every tile carries four edge labels: top, right, bottom, and left (all strings). Two tiles placed next to each other are compatible when their touching edges share the same label.
• A tile can be rotated by 0, 90, 180, or 270 degrees, which rearranges its edge labels.
• Given integers R and C with R*C == N, decide if the tiles can be placed in an R x C grid such that all internal adjacent edges match. (Optionally, also return one valid arrangement of tile IDs and rotations.)
• Assume N is small enough to permit backtracking (for example, N <= 12).

2. ASCII canvas printer

• Build an ASCII drawing engine whose blank canvas is H x W and initially filled with spaces.
• You will be given a list of drawing commands, including:
  • RECT x y width height ch (paint the rectangle with character ch)
  • HLINE x1 x2 y ch (draw a horizontal line)
  • VLINE x y1 y2 ch (draw a vertical line)
• Commands that come later overwrite earlier output.
• Print the final canvas as H lines, each containing W characters.

3. Product of array except self

• Given an integer array nums of length n, return an array out in which out[i] is the product of all nums[j] where j != i.
• Division is not allowed.
• Aim for O(n) time; aside from the output array, extra space should be O(1).

4. 2048 move simulation

• Given a 4 x 4 grid of non-negative integers (powers of two or zero) and a direction chosen from {left, right, up, down}:
  • Move every tile as far as possible in that direction.
  • Merge equal adjacent tiles only once per move (for example, 2 2 2 0 moved left becomes 4 2 0 0, not 8 0 0 0).
• Return the updated grid (optionally, also return the score gained from merges).

Overview: This question set tests algorithmic problem-solving abilities, including backtracking and constraint satisfaction for jigsaw assembly, simulation and state manipulation for ASCII canvas and 2048 move logic, and linear-time in-place array transformation for the product-of-array problem.