TypeScript Are Equally Strong
function areEquallyStrong(
  yourLeft: number,
  yourRight: number,
  friendsLeft: number,
  friendsRight: number
): boolean {
  return (
    Math.max(yourRight, yourLeft) === Math.max(friendsLeft, friendsRight) &&
    Math.min(yourLeft, yourRight) === Math.min(friendsRight, friendsLeft)
  );
}

This compares each person’s strongest and weakest arm. If both pairs match, the result is true.

Bash Array Change
array_change() {
    local -n _a="$1"
    local _min=0 _k _c=${#_a[@]}
    for ((_k = 0; _k < _c - 1; _k++)); do
        if (( _a[_k] >= _a[_k+1] )); then
            local _dif=$(( _a[_k] - _a[_k+1] + 1 ))
            _a[_k+1]=$(( _a[_k+1] + _dif ))
            _min=$(( _min + _dif ))
        fi
    done
    echo "$_min"
}

This moves left to right and bumps values only when needed so the array becomes strictly increasing.

C++ Array Change
#include <vector>

long long arrayChange(std::vector<long long> a)
{
    long long min = 0;
    for (std::size_t k = 0; k + 1 < a.size(); ++k) {
        if (a[k] >= a[k + 1]) {
            long long dif = a[k] - a[k + 1] + 1;
            a[k + 1] += dif;
            min += dif;
        }
    }

    return min;
}

This moves left to right and bumps values only when needed so the array becomes strictly increasing.

C# Array Change
static long ArrayChange(int[] a)
{
    var arr = new long[a.Length];
    Array.Copy(a, arr, a.Length);
    long min = 0;

    for (int k = 0; k < arr.Length - 1; k++)
    {
        if (arr[k] >= arr[k + 1])
        {
            var dif = arr[k] - arr[k + 1] + 1;
            arr[k + 1] += dif;
            min += dif;
        }
    }

    return min;
}

This moves left to right and bumps values only when needed so the array becomes strictly increasing.

Elixir Array Change
defmodule ArrayChange do
  def array_change(a) when length(a) < 2, do: 0

  def array_change(a) do
    {_final, total} =
      Enum.reduce(0..(length(a) - 2), {a, 0}, fn k, {arr, total} ->
        cur = Enum.at(arr, k)
        nxt = Enum.at(arr, k + 1)

        if cur >= nxt do
          diff = cur - nxt + 1
          {List.update_at(arr, k + 1, &(&1 + diff)), total + diff}
        else
          {arr, total}
        end
      end)

    total
  end
end

This moves left to right and bumps values only when needed so the array becomes strictly increasing.

Erlang Array Change
-module(array_change).
-export([array_change/1]).

array_change([H | T]) ->
    {_, Total} = lists:foldl(fun(X, {Prev, Acc}) ->
        case X =< Prev of
            true ->
                New = Prev + 1,
                {New, Acc + (New - X)};
            false ->
                {X, Acc}
        end
    end, {H, 0}, T),
    Total.

This moves left to right and bumps values only when needed so the array becomes strictly increasing.

Go Array Change
func arrayChange(a []int) int {
	moves := 0

	for k := 0; k < len(a)-1; k++ {
		if a[k] >= a[k+1] {
			diff := a[k] - a[k+1] + 1
			a[k+1] += diff
			moves += diff
		}
	}

	return moves
}

This moves left to right and bumps values only when needed so the array becomes strictly increasing.

Haskell Array Change
arrayChange :: [Int] -> Int
arrayChange []       = 0
arrayChange (x : xs) = snd (foldl step (x, 0) xs)
  where
    step (prev, total) cur
      | prev >= cur = (prev + 1, total + (prev - cur + 1))
      | otherwise   = (cur, total)

This moves left to right and bumps values only when needed so the array becomes strictly increasing.

Java Array Change
public class Solution {
    public static long arrayChange(int[] a) {
        long min = 0;
        long[] arr = new long[a.length];
        for (int i = 0; i < a.length; i++) {
            arr[i] = a[i];
        }

        for (int k = 0; k < arr.length - 1; k++) {
            if (arr[k] >= arr[k + 1]) {
                long dif = arr[k] - arr[k + 1] + 1;
                arr[k + 1] += dif;
                min += dif;
            }
        }

        return min;
    }
}

This moves left to right and bumps values only when needed so the array becomes strictly increasing.

Lisp Array Change
(defun array-change (a)
  (let ((vec (coerce a 'vector))
        (min 0))
    (dotimes (k (1- (length vec)))
      (when (>= (aref vec k) (aref vec (1+ k)))
        (let ((dif (+ (- (aref vec k) (aref vec (1+ k))) 1)))
          (incf (aref vec (1+ k)) dif)
          (incf min dif))))
    min))

This moves left to right and bumps values only when needed so the array becomes strictly increasing.