Memory allocation in Blockchain / Solidity - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to allocate memory for a new variable in a smart contract.

Blockchain / Solidity

uint256 public value = [1];

Drag options to blanks, or click blank then click option'

Anone

Bnull

Cundefined

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'null' or 'undefined' which are not valid in Solidity for uint256 initialization.

In blockchain smart contracts, especially Solidity, uninitialized uint256 variables default to 0. Explicitly setting it to 0 allocates memory with a known initial value.

2fill in blank

medium

Complete the code to allocate a dynamic array in memory inside a function.

Blockchain / Solidity

function allocateArray() public pure returns (uint256[] memory) {
    uint256[] memory arr = new uint256[]([1]);
    return arr;
}

Drag options to blanks, or click blank then click option'

A5

Bsize

Clength

Dcount

Attempts:

3 left

💡 Hint

Common Mistakes

Using variable names like 'size' or 'length' without defining them.

When allocating a dynamic array in memory in Solidity, you must specify its fixed size as a number inside the new expression.

3fill in blank

hard

Fix the error in the code to correctly allocate memory for a struct array.

Blockchain / Solidity

struct Data {
    uint256 id;
    string name;
}

function createData() public pure returns (Data[] memory) {
    Data[] memory dataArray = new Data[]([1]);
    return dataArray;
}

Drag options to blanks, or click blank then click option'

Asize

BData

C0

Dlength

Attempts:

3 left

💡 Hint

Common Mistakes

Using the struct name or undefined variables as size.

When allocating memory for an array of structs, you must specify the size as a number. Using '0' creates an empty array without errors.

4fill in blank

hard

Fill both blanks to allocate memory for a bytes array and set its length.

Blockchain / Solidity

function allocateBytes() public pure returns (bytes memory) {
    bytes memory b = new bytes([1]);
    b.length = [2];
    return b;
}

Drag options to blanks, or click blank then click option'

A10

B20

D15

Attempts:

3 left

💡 Hint

Common Mistakes

Setting length to a different value than allocated size.

Using invalid sizes like 20 or 15 when allocation is 10.

In Solidity, you allocate a bytes array with a fixed size using new bytes(size). The length property is read-only for bytes, so setting it to the same size as allocated is consistent.

5fill in blank

hard

Fill all three blanks to allocate memory for a fixed-size array, initialize it, and return the first element.

Blockchain / Solidity

function fixedArray() public pure returns (uint256) {
    uint256[[1]] memory arr;
    arr[[2]] = [3];
    return arr[0];
}

Drag options to blanks, or click blank then click option'

A3

B0

C42

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using index 1 or size 1 which is too small.

Assigning a value other than 42.

The fixed-size array length is 3. The first element index is 0, which is set to 42. Returning arr[0] returns 42.

Practice

1. What is the main purpose of memory in blockchain smart contracts?

easy

A. To temporarily store data during function execution

B. To permanently save user data on the blockchain

C. To allocate gas for contract deployment

D. To encrypt data before storing

Solution

1. Step 1: Understand memory role in smart contracts

   Memory is used to hold data temporarily while a function runs.

2. Step 2: Differentiate memory from storage

   Storage saves data permanently on the blockchain, memory does not.

3. Final Answer:

   To temporarily store data during function execution -> Option A

4. Quick Check:

   Memory = Temporary data space [OK]

Hint: Memory is temporary, storage is permanent [OK]

Common Mistakes:

• Confusing memory with storage
• Thinking memory saves data permanently
• Assuming memory costs more gas

2. Which of the following is the correct syntax to declare a dynamic array in memory in Solidity?

easy

A. uint[] myArray = memory new uint[](5);

B. uint[] storage myArray = new uint[](5);

C. memory uint[] myArray = new uint[](5);

D. uint[] memory myArray = new uint[](5);

Solution

1. Step 1: Recall correct memory array declaration syntax

   In Solidity, dynamic memory arrays are declared as type[] memory var = new type[](size);

2. Step 2: Check each option

   uint[] memory myArray = new uint[](5); matches the correct syntax exactly.

3. Final Answer:

   uint[] memory myArray = new uint[](5); -> Option D

4. Quick Check:

   Memory array syntax = uint[] memory myArray = new uint[](5); [OK]

Hint: Use 'memory' keyword before variable name for memory arrays [OK]

Common Mistakes:

• Using 'storage' instead of 'memory' for temporary arrays
• Placing 'memory' after variable name incorrectly
• Omitting 'new' keyword for dynamic arrays

3. What will be the output of this Solidity function snippet?

function test() public pure returns (uint) {
    uint[] memory arr = new uint[](3);
    arr[0] = 10;
    arr[1] = 20;
    arr[2] = 30;
    return arr[1];
}

medium

A. 10

B. 20

C. 30

D. 0

Solution

1. Step 1: Analyze array assignments

   Array elements are set as arr[0]=10, arr[1]=20, arr[2]=30.

2. Step 2: Identify returned value

   The function returns arr[1], which is 20.

3. Final Answer:

   20 -> Option B

4. Quick Check:

   arr[1] = 20 [OK]

Hint: Remember array indexing starts at 0 [OK]

Common Mistakes:

• Confusing index 1 with index 0
• Assuming default zero value is returned
• Misreading array initialization

4. Identify the error in this Solidity function that tries to copy a storage array to memory:

uint[] public data;

function copyArray() public {
    uint[] memory temp = data;
}

medium

A. Cannot assign storage array directly to memory array

B. Missing visibility keyword for storage array

C. Memory arrays cannot be declared inside functions

D. Function must be marked as pure

Solution

1. Step 1: Understand storage to memory assignment rules

   Direct assignment from storage array to memory array is not allowed in Solidity.

2. Step 2: Identify correct error

   The code tries to assign data (storage) directly to temp (memory), causing a compilation error.

3. Final Answer:

   Cannot assign storage array directly to memory array -> Option A

4. Quick Check:

   Storage to memory direct assignment = Error [OK]

Hint: Copy elements manually from storage to memory [OK]

Common Mistakes:

• Assuming direct assignment copies array
• Ignoring visibility requirements
• Marking function pure incorrectly

5. You want to create a function that returns a new memory array containing only the even numbers from a given storage array. Which approach correctly uses memory allocation?

hard

A. Declare a memory array with length zero, push evens dynamically, then return it

B. Declare a storage array, copy evens, then return it

C. Declare a memory array with max length, copy evens manually, then return a sliced array

D. Declare a memory array with the same length as storage, copy evens, then resize the array

Solution

1. Step 1: Understand memory array limitations

   Memory arrays in Solidity have fixed size; cannot push dynamically.

2. Step 2: Choose correct approach for filtering

   Declare a memory array with max length, copy even numbers manually, then return a sliced array with correct size.

3. Final Answer:

   Declare a memory array with max length, copy evens manually, then return a sliced array -> Option C

4. Quick Check:

   Memory arrays fixed size = Declare a memory array with max length, copy evens manually, then return a sliced array [OK]

Hint: Memory arrays fixed size; slice after copying [OK]

Common Mistakes:

• Trying to push to memory arrays
• Using storage arrays for temporary filtering
• Not resizing array before returning