Unorder Of Operations - FreeCodeCamp Daily Challenge

Unorder Of Operations - Analysis & Explanation

Problem Statement

Given an array of integers and an array of operators (as strings), apply the operations from left to right, ignoring standard mathematical precedence. Operators repeat in order if there are more numbers than operators. Return the final result.

Example:

• Numbers: $[1,\, 2,\, 3,\, 4,\, 5]$
• Operators: $['+',\, '*']$

Evaluate strictly left to right:

Each operation is performed in order, regardless of operator type.

Valid operators: $+$, $-$, $\times$, $\div$, $\%$ (modulo).

Initial Analysis

What does the problem ask?

Iterate through the numbers array and apply the operators in order, ignoring mathematical precedence. Operators repeat if there are more numbers than operators. The result is obtained by performing each operation in sequence.

Key Test Cases

Consider the following scenarios:

• Operators repeat and are applied strictly left to right.
• All valid operators: addition ($+$), subtraction ($-$), multiplication ($\times$), division ($\div$), modulo ($\%$).
• Arrays of different lengths, verifying cyclic repetition of operators.
• Negative results, divisions, and modulo operations.

Examples:

• $\texttt{evaluate([5,\, 6,\, 7,\, 8,\, 9],\ ['+',\ '-'])}$ → $3$
• \texttt{evaluate([17,\, 61,\, 40,\, 24,\, 38,\, 14],\ ['+',\ '%'])} → $38$
• $\texttt{evaluate([20,\, 2,\, 4,\, 24,\, 12,\, 3],\ ['*',\ '/'])}$ → $60$
• \texttt{evaluate([11,\, 4,\, 10,\, 17,\, 2],\ ['*',\ '*',\ '%'])} → $30$
• $\texttt{evaluate([33,\, 11,\, 29,\, 13],\ ['/',\ '-'])}$ → $-2$

Solution Development

Approach

Iterate through the numbers array, applying the corresponding operator at each step, ignoring precedence. The operator is selected cyclically. The result is accumulated and returned at the end.

Implementation

1. Initialize the result with the first number.
2. Iterate through the rest of the numbers.
3. Select the operator using the index, repeating if necessary.
4. Apply the operation between the accumulator and the current number.
5. Return the result.

Code:

/**
 * Sequentially applies arithmetic operations from left to right on an array of numbers,
 * ignoring standard precedence. Operators repeat in order if needed.
 * @param {number[]} numbers - Numbers to evaluate.
 * @param {string[]} operators - Operators ('+', '-', '*', '/', '%').
 * @returns {number} Final result.
 */
function evaluate(numbers, operators) {
  let result = numbers[0]
  for (let i = 1; i < numbers.length; i++) {
    const op = operators[(i - 1) % operators.length]
    const num = numbers[i]
    switch (op) {
      case '+': result += num; break
      case '-': result -= num; break
      case '*': result *= num; break
      case '/': result = Math.trunc(result / num); break
      case '%': result %= num; break
    }
  }
  return result
}

export default evaluate

Explanation: The loop iterates through the numbers, applying the corresponding operator at each step, selected cyclically. The switch block applies the indicated operation. Math.trunc ensures integer division. The function returns the accumulated result.

Complexity Analysis

Time: $\mathcal{O}(n)$, where $n$ is the number of elements.

Space: $\mathcal{O}(1)$, only one accumulator variable is used.

Edge Cases & Considerations

• If there are fewer operators than numbers, they repeat in order.
• Assumes valid input: no division by zero or invalid operators.
• Division is truncated toward zero to match the examples.

Reflections & Learnings

Concepts: Simulation, array handling, use of for loop and switch for dynamic operations.

Optimizations: The solution is optimal for this problem. If input validation or error handling is needed, extra checks can be added.

Resources

• JavaScript Arithmetic Operators
• Math.trunc in JavaScript
• Original problem at freeCodeCamp