Storage vs memory usage in Blockchain / Solidity - Practice Questions

Challenge - 5 Problems

❓ Predict Output

intermediate

Understanding storage and memory in Solidity

What will be the output of this Solidity function when called?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Test {
    uint[] public numbers;

    function addNumbers() public returns (uint) {
        uint[] memory temp = new uint[](3);
        temp[0] = 1;
        temp[1] = 2;
        temp[2] = 3;

        numbers = temp;
        return numbers.length;
    }
}

A 0

B Runtime error

C Compilation error

D 3

💡 Hint

Remember that assigning a memory array to a storage array copies the data.

The function creates a memory array of length 3, assigns values, then copies it to the storage array 'numbers'. The storage array length becomes 3, so the function returns 3.

❓ Predict Output

intermediate

Effect of modifying memory vs storage variables

What will be the value of 'data[0]' after calling 'modify()'?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Example {
    uint[] public data;

    constructor() {
        data.push(10);
        data.push(20);
    }

    function modify() public {
        uint[] memory temp = data;
        temp[0] = 99;
    }
}

A 10

B 99

C Compilation error

D Runtime error

💡 Hint

Modifying a memory copy does not affect storage.

The 'temp' array is a memory copy of 'data'. Changing 'temp[0]' does not change 'data[0]' in storage, so 'data[0]' remains 10.

🧠 Conceptual

advanced

Gas cost difference between storage and memory

Which statement about gas costs in Solidity is correct?

A Reading from storage is cheaper than reading from memory.

B Writing to storage is more expensive than writing to memory.

C Memory usage permanently increases gas cost after function execution.

D Storage variables are temporary and cheaper to use than memory variables.

💡 Hint

Consider the permanence of storage vs memory.

Writing to storage is expensive because it changes the blockchain state permanently. Memory is temporary and cheaper to write to during function execution.

❓ Predict Output

advanced

Storage pointer vs memory copy behavior

What will be the output of the function 'getFirst()' after calling 'update()'?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract PointerTest {
    uint[] public arr;

    constructor() {
        arr.push(5);
        arr.push(10);
    }

    function update() public {
        uint[] storage ref = arr;
        ref[0] = 100;
    }

    function getFirst() public view returns (uint) {
        return arr[0];
    }
}

A 100

B 0

C 5

D Compilation error

💡 Hint

Storage pointers modify the original storage data.

The 'ref' variable is a storage pointer to 'arr'. Changing 'ref[0]' changes 'arr[0]' in storage, so 'getFirst()' returns 100.

🧠 Conceptual

expert

Choosing storage vs memory for function parameters

Which is the best reason to use 'memory' instead of 'storage' for a function parameter in Solidity?

A To allow the function to modify the original storage variable directly.

B To permanently save changes to the blockchain state.

C To reduce gas costs by avoiding expensive storage writes.

D To make the variable accessible outside the function.

💡 Hint

Think about temporary data and gas costs.

Using 'memory' creates a temporary copy that does not write to storage, saving gas. 'Storage' parameters refer to persistent blockchain data and are more expensive to modify.

Practice

1. Which of the following best describes storage in blockchain smart contracts?

easy

A. Permanent data saved on the blockchain that persists between function calls.

B. Temporary data used only during a function execution and discarded afterward.

C. Data stored off-chain for faster access.

D. Encrypted data that cannot be accessed by the contract.

Solution

1. Step 1: Understand storage purpose

   Storage holds data permanently on the blockchain, so it remains after function execution.

2. Step 2: Compare with memory

   Memory is temporary and only lasts during function execution, unlike storage.

3. Final Answer:

   Permanent data saved on the blockchain that persists between function calls. -> Option A

4. Quick Check:

   Storage = permanent data [OK]

Hint: Storage keeps data after functions finish, memory does not [OK]

Common Mistakes:

• Confusing memory with storage permanence
• Thinking storage is temporary
• Assuming storage is off-chain
• Believing storage is encrypted by default

2. Which of the following is the correct way to declare a variable in Solidity that uses memory?

easy

A. uint memory[] numbers;

B. uint[] storage numbers;

C. memory uint[] numbers;

D. uint[] memory numbers;

Solution

1. Step 1: Recall Solidity syntax for memory arrays

   In Solidity, the correct syntax is type[] memory variableName; for memory arrays.

2. Step 2: Check each option

   uint[] memory numbers; matches the correct syntax: uint[] memory numbers;. Others have wrong order or keywords.

3. Final Answer:

   uint[] memory numbers; -> Option D

4. Quick Check:

   Memory arrays use 'type[] memory name' syntax [OK]

Hint: Memory keyword comes after type and brackets in Solidity [OK]

Common Mistakes:

• Placing 'memory' before type
• Using 'storage' instead of 'memory'
• Incorrect array syntax
• Missing brackets for array type

3. What will be the output of the following Solidity function?

pragma solidity ^0.8.0;
contract Test {
    uint[] storageArray;
    function addAndReturn() public returns (uint) {
        uint[] memory tempArray = new uint[](1);
        tempArray[0] = 5;
        storageArray.push(10);
        return tempArray[0];
    }
}

medium

A. 0

B. 10

C. 5

D. Compilation error

Solution

1. Step 1: Analyze tempArray usage

   The function creates a memory array with one element set to 5, then returns that element.

2. Step 2: Understand storageArray effect

   storageArray.push(10) adds 10 to storage but does not affect the returned value.

3. Final Answer:

   5 -> Option C

4. Quick Check:

   Return value from memory array = 5 [OK]

Hint: Return value from memory array, storage change doesn't affect output [OK]

Common Mistakes:

• Confusing storage push with return value
• Expecting storageArray value as output
• Thinking memory array persists after function
• Assuming compilation error due to storage usage

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

pragma solidity ^0.8.0;
contract Example {
    uint[] storageArray;
    function copyArray() public view returns (uint[] memory) {
        uint[] memory tempArray = storageArray;
        return tempArray;
    }
}

medium

A. Cannot assign storage array directly to memory array.

B. Function must be non-view to modify storage.

C. Missing visibility specifier for storageArray.

D. Memory arrays cannot be returned from functions.

Solution

1. Step 1: Understand storage to memory assignment

   In Solidity, you cannot directly assign a storage array to a memory array variable.

2. Step 2: Identify correct copying method

   You must copy elements manually or use a loop to transfer data from storage to memory.

3. Final Answer:

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

4. Quick Check:

   Direct storage to memory assignment is invalid [OK]

Hint: Storage arrays need manual copying to memory arrays [OK]

Common Mistakes:

• Trying direct assignment from storage to memory
• Ignoring need for loops to copy arrays
• Assuming view functions can modify storage
• Believing memory arrays can't be returned

5. You want to write a Solidity function that temporarily modifies an array for calculations without changing the stored data. Which is the best approach?

hard

A. Declare the array as memory in the contract state.

B. Copy the storage array to a memory array, modify the memory array, then discard it.

C. Use a storage pointer to the array and modify it temporarily.

D. Modify the storage array directly and revert changes after calculations.

Solution

1. Step 1: Understand temporary modification needs

   To avoid changing stored data, use a memory copy for temporary changes.

2. Step 2: Evaluate options

   Copy the storage array to a memory array, modify the memory array, then discard it. copies storage to memory, modifies memory, and discards changes, preserving storage.

3. Step 3: Reject incorrect options

   A declares memory in state (invalid syntax); B risks permanent changes if revert fails; C modifies storage directly.

4. Final Answer:

   Copy the storage array to a memory array, modify the memory array, then discard it. -> Option B

5. Quick Check:

   Use memory copy for temporary changes [OK]

Hint: Use memory copy to avoid changing stored data permanently [OK]

Common Mistakes:

• Modifying storage directly for temporary needs
• Trying to declare storage variables as memory in contract
• Assuming revert undoes all changes safely
• Using storage pointers for temporary changes