Initialize Special Tensors

easyFREEBasic OpsPyTorch BasicsPytorch

Problem Statement

Create a tensor filled with a chosen pattern.

Background

PyTorch provides functions to create tensors with specific initial values:

torch.zeros(shape) - every element is 0
torch.ones(shape) - every element is 1
torch.rand(shape) - uniform random values in [0, 1)

These are the building blocks for weight initialization, masks and padding.

Your Task

Write a function create_special_tensor(shape, fill_type) that returns a tensor of the given shape:

"zeros" → a tensor of zeros
"ones" → a tensor of ones
"random" → a tensor of uniform random values in [0, 1)
any other fill_type → return None

Output Format

Return a PyTorch tensor (float32), or None for an invalid fill_type.

Example

Input

(2, 2), "ones"

Output

tensor([[1., 1.],
        [1., 1.]])

Reasoning

Inputs: shape is (2, 2), meaning 2 rows and 2 columns, so the result holds $2 \times 2 = 4$ elements. fill_type is "ones", which says every one of those elements should have the value $1$ .
Math: the output is the constant matrix $T \in \mathbb{R}^{2 \times 2}$ with $T_{ij} = 1$ for every row $i$ and column $j$ , i.e. $T = \begin{pmatrix} 1 & 1 \\ 1 & 1 \end{pmatrix}$ . Nothing depends on position, only on the pattern name.
Output: the tensor tensor([[1., 1.], [1., 1.]]). The trailing dots mark the entries as floating-point numbers (32-bit, as the output format requires), not integers.
Notice that shape only controls how many entries there are and how they are arranged: a $1 \times 4$ shape with the zeros pattern gives a single row of four $0$ s. With the random pattern, each entry is instead drawn uniformly from $[0, 1)$ , so values change on every call, and an unknown fill_type gives None instead of a tensor.

Constraints

shape is a tuple of positive integers
fill_type is one of: "zeros", "ones", "random"
Return None for invalid fill_type

Learn this in

PyTorch FundamentalsFoundations

More from Pytorch

Apply Softmax for Predictionseasy Count Model Parametersmedium Build with nn.Sequentialeasy Use nn.Flatten Layereasy Create a Simple Neural Network Classeasy

Concept primer

1. Background Knowledge

Special tensors — all zeros, all ones, or uniform random values — are the starting point for most tensors in deep learning: weight initialization, masks, padding and accumulators. PyTorch creates each one with a single call that takes a shape:

torch.zeros(shape): every element is 0. Used for biases, accumulators (e.g. running gradient sums) and zero-padding.
torch.ones(shape): every element is 1. Used for attention masks, scaling factors and "keep everything" masks.
torch.rand(shape): values drawn uniformly from $[0, 1)$ . The raw material for random initialization and dropout masks.

All three return float32 tensors by default, which is why they print with a decimal point: tensor([[1., 1.], [1., 1.]]).

2. Algorithm / General Approach

This is a dispatch problem: look at fill_type, call the matching constructor with shape, and return None for anything else.

CreateSpecialTensor(shape, fill_type):
    if fill_type == "zeros":  return zeros(shape)
    if fill_type == "ones":   return ones(shape)
    if fill_type == "random": return uniform_random(shape)
    return None

3. Step-by-Step Strategy

Compare fill_type exactly: the valid values are the lowercase strings "zeros", "ones" and "random".
Pass shape straight through: torch.zeros((2, 3)) accepts the tuple as-is, so there's no need to unpack it.
Return the tensor itself, not a list. The tests print it, so the expected output is PyTorch's tensor repr.
Fall through to None for unknown fill types instead of raising an error.

Example: create_special_tensor((2, 2), "ones") → tensor([[1., 1.], [1., 1.]]); create_special_tensor((2, 2), "eye") → None.

4. Common Pitfalls

Returning nested lists (.tolist()): the printed output then shows [[1.0, 1.0], ...] instead of tensor([[1., 1.], ...]) and won't match.
Using torch.randn for "random": that samples a normal distribution (it can be negative); "random" here means uniform $[0, 1)$ (torch.rand).
Raising on an invalid fill_type: the contract is to return None.
Integer dtype: torch.zeros(shape, dtype=torch.int64) prints tensor([[0, 0], ...]) without decimals. Keep the float32 default.

5. Time & Space Complexity

For a tensor with $N = \prod \text{shape}$ elements, creation is $O(N)$ time and $O(N)$ space: every element is written once.

solution.py

Python 3.13

Test results