LeetCode //C - 1033. Moving Stones Until Consecutive

1033. Moving Stones Until Consecutive

There are three stones in different positions on the X-axis. You are given three integers a, b, and c, the positions of the stones.

In one move, you pick up a stone at an endpoint (i.e., either the lowest or highest position stone), and move it to an unoccupied position between those endpoints. Formally, let's say the stones are currently at positions x, y, and z with x < y < z. You pick up the stone at either position x or position z, and move that stone to an integer position k, with x < k < z and k != y.

The game ends when you cannot make any more moves (i.e., the stones are in three consecutive positions).

Return an integer array answer of length 2 where:

answer $0$ is the minimum number of moves you can play, and
answer $1$ is the maximum number of moves you can play.

Example 1:

Input: a = 1, b = 2, c = 5
Output: $1,2$
Explanation: Move the stone from 5 to 3, or move the stone from 5 to 4 to 3.

Example 2:

Input: a = 4, b = 3, c = 2
Output: $0,0$
Explanation: We cannot make any moves.

Example 3:

Input: a = 3, b = 5, c = 1
Output: $1,2$
Explanation: Move the stone from 1 to 4; or move the stone from 1 to 2 to 4.

Constraints:

1 <= a, b, c <= 100
a, b, and c have different values.

From: LeetCode

Link: 1033. Moving Stones Until Consecutive

Solution:

Ideas:

First sort the three positions so a < b < c.
Let the gaps be b-a and c-b.
Maximum moves = total empty spots between the outer stones = c - a - 2.
Minimum moves:
- 0 if already consecutive.
- 1 if one gap is 2 or less, because one move can make them consecutive.
- otherwise 2.

Code:

c 复制代码

static void sort3(int *x, int *y, int *z) {
    int t;
    if (*x > *y) { t = *x; *x = *y; *y = t; }
    if (*y > *z) { t = *y; *y = *z; *z = t; }
    if (*x > *y) { t = *x; *x = *y; *y = t; }
}

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* numMovesStones(int a, int b, int c, int* returnSize) {
    sort3(&a, &b, &c);   // make sure a < b < c
    
    int *ans = (int *)malloc(sizeof(int) * 2);
    *returnSize = 2;
    
    int leftGap = b - a;
    int rightGap = c - b;
    
    /* maximum moves:
       keep shrinking the larger interval one step at a time */
    ans[1] = (c - a - 2);
    
    /* minimum moves */
    if (leftGap == 1 && rightGap == 1) {
        ans[0] = 0;              // already consecutive
    } else if (leftGap <= 2 || rightGap <= 2) {
        ans[0] = 1;              // one special jump can finish it
    } else {
        ans[0] = 2;              // otherwise need two moves
    }
    
    return ans;
}