Array-to-Array Operations

easyFREEArray MathematicsNumPy MathematicsNumpy

Problem Statement

Perform element-wise operations between two arrays.

Background

When arrays have the same shape, operations are element-wise:

arr1 + arr2  # Element-wise addition
arr1 * arr2  # Element-wise multiplication

Your Task

Write a function array_operations(arr1, arr2) that returns a dictionary with:

"add": Element-wise addition as list
"multiply": Element-wise multiplication as list
"dot": Dot product (sum of element-wise multiplication) as a plain Python integer

Output Format

Return a dictionary with exactly these three keys.

Example

Input

arr1 = [1, 2, 3], arr2 = [4, 5, 6]

Output

{'add': [5, 7, 9], 'multiply': [4, 10, 18], 'dot': 32}

Reasoning

Inputs: arr1 $= [1, 2, 3]$ and arr2 $= [4, 5, 6]$ are two vectors of the same length $n = 3$ . Position $i$ of one is paired with position $i$ of the other, so $a_1 \leftrightarrow b_1$ , $a_2 \leftrightarrow b_2$ , $a_3 \leftrightarrow b_3$ .
add: each entry is $a_i + b_i$ : $1+4=5$ , $2+5=7$ , $3+6=9$ , giving [5, 7, 9]. The result has the same length as the inputs.
multiply: each entry is $a_i \cdot b_i$ : $1 \cdot 4=4$ , $2 \cdot 5=10$ , $3 \cdot 6=18$ , giving [4, 10, 18]. Also length 3.
dot: the dot product collapses those products into one number, $\mathbf{a} \cdot \mathbf{b} = \sum_{i=1}^{n} a_i b_i = 4 + 10 + 18 = 32$ .
Output: a dictionary with keys add, multiply and dot. The first two are plain lists of $n$ numbers; dot is a single integer, a scalar rather than a vector.
Notice that dot is exactly the sum of the multiply entries, so the two must always agree.

Constraints

Both arrays will have the same shape
Use np.dot() for dot product

Learn this in

NumPy & Data WranglingFoundations

Concept primer

Background Knowledge for Array-to-Array Operations

1. Background Knowledge

NumPy Arrays and Element-wise Operations

NumPy arrays are the standard representation for numerical data in Python and enable efficient implementation of numerical computations in a high-level language. Unlike Python lists, NumPy arrays support vectorized operations—computations that operate on entire arrays without explicit loops.

Element-wise operations apply a function to corresponding elements in two arrays of the same shape. For arrays $A$ and $B$ :

Element-wise addition: $C[i] = A[i] + B[i]$
Element-wise multiplication: $C[i] = A[i] \times B[i]$

These operations are fundamentally different from matrix operations like the dot product, which combines elements across dimensions.

Dot Product

The dot product (also called scalar product or inner product) between two 1D arrays is:

\text{dot}(A, B) = \sum_{i=0}^{n-1} A[i] \times B[i]

For the sample input [1, 2, 3] and [4, 5, 6]: $1 \times 4 + 2 \times 5 + 3 \times 6 = 4 + 10 + 18 = 32$

2. Algorithm Approach

Vectorization Technique

Vectorization is a technique for converting an algorithm that operates on single values to one that operates on collections of values simultaneously. NumPy performs vectorized calculations efficiently by:

Avoiding explicit loops: Operations are compiled into optimized C code
Minimizing memory copies: Data is processed in-place when possible
Reducing operation counts: Batch operations are faster than iterative approaches

Implementation Strategy

For this problem, leverage NumPy's built-in operators:

- operator for element-wise addition
- operator for element-wise multiplication
np.dot() for dot product computation

3. Step-by-Step Strategy

Step 1: Import NumPy

import numpy as np

Step 2: Perform element-wise addition

add_result = arr1 + arr2

Step 3: Perform element-wise multiplication

multiply_result = arr1 * arr2

Step 4: Calculate dot product

dot_result = np.dot(arr1, arr2)

Step 5: Convert NumPy arrays to lists and return as dictionary

return {
 "add": add_result.tolist(),
 "multiply": multiply_result.tolist(),
 "dot": dot_result.item() # or int(dot_result) for scalar
}

Complete Solution

import numpy as np

def array_operations(arr1, arr2):
 add_result = arr1 + arr2
 multiply_result = arr1 * arr2
 dot_result = np.dot(arr1, arr2)

 return {
 "add": add_result.tolist(),
 "multiply": multiply_result.tolist(),
 "dot": int(dot_result)
 }

4. Common Pitfalls

Forgetting .tolist() conversion: The problem requires lists in the output, not NumPy arrays. Use .tolist() to convert.
Confusing * with matrix multiplication: In NumPy, * performs element-wise multiplication, not matrix multiplication (use @ or np.dot() for that).
Incorrect dot product calculation: Ensure you use np.dot() as specified, not manual summation of element-wise products.
Type mismatch for scalar dot product: The dot product returns a NumPy scalar; convert it to a Python int using .item() or direct casting.
Assuming different shapes: The problem guarantees same-shaped arrays, but always validate in production code.

5. Time & Space Complexity

Operation	Time Complexity	Space Complexity
Element-wise addition	O(n)	O(n)
Element-wise multiplication	O(n)	O(n)
Dot product	O(n)	O(1)
Overall	O(n)	O(n)

Where $n$ is the total number of elements in the arrays. NumPy's vectorized operations execute in linear time with respect to array size, making them far more efficient than Python loops for large arrays.

solution.py

Python 3.13

Test results