Memory allocation in Blockchain / Solidity - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Memory usage in Solidity storage vs memory

Consider the following Solidity function that copies an array from storage to memory and modifies it. What will be the value of arr[0] in storage after calling modifyArray()?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Test {
    uint[] public arr = [1, 2, 3];

    function modifyArray() public {
        uint[] memory temp = arr;
        temp[0] = 100;
    }
}

A 100

B 1

C 0

D Compilation error

💡 Hint

Remember that memory variables are copies and do not affect storage unless explicitly written back.

The temp array is a copy of arr in memory. Modifying temp[0] does not change the original arr in storage. So, arr[0] remains 1.

🧠 Conceptual

intermediate

Understanding stack vs heap in smart contracts

Which statement correctly describes the difference between stack and heap memory in blockchain smart contracts?

A Stack and heap memory are the same in smart contracts.

B Stack memory is dynamic and used for large data, heap is fixed size and used for small variables.

C Heap memory is faster than stack memory and used for temporary variables.

D Stack memory stores local variables and function calls, heap memory stores dynamically allocated data like arrays and structs.

💡 Hint

Think about where local variables and dynamic data are stored during execution.

Stack memory holds local variables and function call data, which is fixed size and fast. Heap memory is used for dynamic data like arrays and structs.

🔧 Debug

advanced

Detecting memory allocation error in Solidity

What error will the following Solidity code produce when compiled?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Demo {
    function test() public pure returns (uint) {
        uint[] memory arr;
        arr[0] = 10;
        return arr[0];
    }
}

A Runtime error: Out of bounds memory access

B Returns 10

C Compilation error: Memory array must have fixed length

D Compilation error: Missing return statement

💡 Hint

Think about how memory arrays must be declared in Solidity.

Memory arrays must have a fixed length when declared. Declaring uint[] memory arr; without length causes a compilation error.

❓ Predict Output

advanced

Gas cost impact of storage vs memory

What will be the gas cost difference when running the following two functions in Solidity?

Function storeData() writes to storage, useMemory() uses memory only.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract GasTest {
    uint[] public data;

    function storeData() public {
        for (uint i = 0; i < 5; i++) {
            data.push(i);
        }
    }

    function useMemory() public pure returns (uint) {
        uint[] memory temp = new uint[](5);
        for (uint i = 0; i < 5; i++) {
            temp[i] = i;
        }
        return temp[4];
    }
}

A storeData() costs more gas because storage writes are expensive; useMemory() costs less as memory is cheaper

B Both functions cost the same gas because they do similar loops

C useMemory() costs more gas because memory allocation is expensive

D storeData() costs less gas because storage is persistent

💡 Hint

Recall that writing to blockchain storage is more costly than using temporary memory.

Writing to storage consumes much more gas than using memory because storage changes are permanent and stored on-chain. Memory is temporary and cheaper.

🧠 Conceptual

expert

Memory allocation and reentrancy vulnerability

How can improper memory allocation contribute to a reentrancy attack vulnerability in a smart contract?

A Memory allocation has no impact on reentrancy since it is only temporary and isolated per call.

B Improper memory allocation causes out-of-gas errors, which prevent reentrancy.

C Reentrancy attacks happen only due to storage variables, memory allocation is irrelevant.

D If memory variables are not cleared properly, attackers can reuse them to manipulate contract state during reentrant calls.

💡 Hint

Memory is temporary and isolated per execution context in smart contracts.

Memory allocation has no impact on reentrancy since it is only temporary and isolated per call.

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