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.