Identity and Eye Matrices

easyFREEI/ONumPy Array CreationNumpy

Problem Statement

Create identity matrices using NumPy.

Background

np.eye(n): Creates n×n identity matrix (1s on diagonal, 0s elsewhere)
np.identity(n): Same as eye, but only square matrices
Identity matrix: I × A = A (identity element for matrix multiplication)

Your Task

Write a function create_identity(n) that returns a dictionary with:

"identity": n×n identity matrix as nested list
"trace": Sum of diagonal elements (should equal n)
"shape": Shape as list [n, n]

Output Format

Return a dictionary with exactly these three keys.

Example

Input

n = 3

Output

{'identity': [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]], 'trace': 3.0, 'shape': [3, 3]}

Reasoning

Input: n = 3 is the side length of a square matrix, so the result has 3 rows and 3 columns.
Math: the identity matrix $I_3$ has entries $I_{ij} = 1$ when $i = j$ and $I_{ij} = 0$ otherwise. Row 1 is $(1, 0, 0)$ , row 2 is $(0, 1, 0)$ , row 3 is $(0, 0, 1)$ : the ones run down the main diagonal.
Trace: the trace is the sum of the diagonal entries, $\operatorname{tr}(I_3) = I_{11} + I_{22} + I_{33} = 1 + 1 + 1 = 3$ . For any size the trace equals $n$ .
Output: identity holds the three rows as nested lists, trace is 3.0, and shape is [3, 3] (rows, then columns).
Notice the entries and the trace are written as floats (1.0, 3.0), while the shape values are plain integers, since they count rows and columns rather than store matrix values.
Why it matters: $I A = A$ for any $3 \times 3$ matrix $A$ , which is why $I$ is the identity element of matrix multiplication.

Constraints

Use np.eye() or np.identity()
n will be a positive integer

Concept primer

1. Background Knowledge

Identity matrices are square matrices $I_n \in \mathbb{R}^{n \times n}$ with 1s on the main diagonal and 0s elsewhere, serving as the multiplicative identity: $I_n \cdot A = A \cdot I_n = A$ for any compatible matrix $A$ .

NumPy provides efficient n-dimensional array operations central to scientific Python computing. Key functions:

np.eye(n): Returns $n \times n$ identity matrix as a float NumPy array (dtype float64 by default).
np.identity(n): Identical to np.eye(n) for square matrices.

Trace of a matrix is the sum of its diagonal elements: $\operatorname{trace}(I_n) = n$ , since only diagonal 1s contribute.

Shape is the tuple (n, n) converted to list [n, n] for the output.

Prerequisites: Basic NumPy array handling, list comprehension for nested lists, dictionary creation.

2. Algorithm Approach

Use np.eye(n) (or np.identity(n)) to generate the identity array directly—no manual construction needed, as it's $O(n^2)$ optimized in C.

Generate identity array.
Compute trace via np.trace() or np.diagonal().sum() ( $O(n)$ ).
Extract shape and convert to list.
Convert array to nested list via array.tolist().

This leverages NumPy's vectorized operations for efficiency over pure Python loops.

3. Step-by-Step Strategy

import numpy as np

def create_identity(n):
 # Step 1: Create n x n identity matrix (float64)
 identity_array = np.eye(n)

 # Step 2: Compute trace (sum of diagonal = n)
 trace = np.trace(identity_array)

 # Step 3: Get shape as list
 shape = list(identity_array.shape)

 # Step 4: Convert to nested list (preserves float values like 1.0)
 identity_list = identity_array.tolist()

 # Step 5: Return exact dictionary format
 return {
 "identity": identity_list,
 "trace": trace,
 "shape": shape
 }

Verification:

result = create_identity(3)
print(result["identity"] == [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]]) # True
print(result["trace"] == 3.0) # True
print(result["shape"] == [3, 3]) # True

4. Common Pitfalls

Data type mismatch: np.eye(n) returns floats (1.0, not 1); sample expects 1.0—.tolist() preserves this.
Shape as tuple: array.shape is (n, n); must convert to [n, n] list.
Manual loops: Avoid for loops to build matrix—use np.eye() for $O(1)$ logical time.
Integer input: n is positive integer, but output trace/shape use float/list—no casting needed.
Import missing: Always import numpy as np.
Non-square: Constraints guarantee square; no need for rectangular handling.

5. Time & Space Complexity

Time: $O(n^2)$ dominant from np.eye() allocation and .tolist() traversal. Trace is $O(n)$ .
Total: $\Theta(n^2)$ , optimized via C backend (vectorized, no Python loops).
Space: $O(n^2)$ for array storage (dense matrix).
Auxiliary: $O(n^2)$ for list conversion; dictionary overhead $O(1)$ .
Identity matrix sparsity unused here (all zeros explicit).

This approach is optimal for constraints, scaling linearly in memory but constant-time logically via NumPy primitives.

solution.py

Python 3.13

Test results