Gas optimization with storage in Blockchain / Solidity - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Gas cost difference between storage and memory

Consider the following Solidity function that copies an array from storage to memory and modifies it. What is the expected gas cost behavior when modifying the storage array directly versus modifying the memory copy?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract GasTest {
    uint256[] public data;

    constructor() {
        data.push(1);
        data.push(2);
        data.push(3);
    }

    function modifyStorage() public {
        data[0] = 10;
    }

    function modifyMemory() public view returns (uint256[] memory) {
        uint256[] memory temp = data;
        temp[0] = 10;
        return temp;
    }
}

A modifyStorage uses more gas because it writes to storage; modifyMemory uses less gas as it only modifies memory.

B modifyMemory uses more gas because copying to memory is expensive; modifyStorage uses less gas as it modifies storage directly.

C Both functions use the same amount of gas because they modify the same data values.

D modifyStorage uses less gas because storage writes are cheaper than memory writes.

💡 Hint

Think about the cost difference between writing to storage and writing to memory in Solidity.

Writing to storage is expensive in Solidity because it changes the blockchain state. Memory operations are cheaper but temporary. So modifying storage costs more gas than modifying memory.

🧠 Conceptual

intermediate

Why pack variables to save gas?

In Solidity, why does packing multiple smaller variables into a single storage slot reduce gas costs?

A Because packed variables execute faster in the EVM bytecode, reducing gas.

B Because each storage slot costs gas, packing reduces the number of slots used, lowering gas consumption.

C Because packing variables increases the contract size, which reduces gas costs.

D Because packed variables are stored off-chain, saving gas.

💡 Hint

Think about how storage slots are charged in Solidity.

Each 32-byte storage slot costs gas. Packing smaller variables into one slot reduces the total slots used, saving gas on storage operations.

🔧 Debug

advanced

Identify the gas inefficiency in this contract

Look at the following Solidity contract. Which line causes unnecessary gas usage due to inefficient storage access?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Inefficient {
    uint256 public count;

    function increment() public {
        count = count + 1;
        count = count + 1;
    }
}

A Using 'count++' would cause more gas usage than 'count = count + 1;'.

B The contract lacks a constructor, causing gas inefficiency.

C The function should be marked view to save gas.

D Line 'count = count + 1;' repeated twice causes two storage writes, increasing gas.

💡 Hint

Consider how many times the storage variable is written to.

Each write to a storage variable costs gas. Writing twice separately causes double the gas cost. Combining increments before writing once saves gas.

📝 Syntax

advanced

Which code snippet correctly uses 'unchecked' to save gas?

In Solidity, using 'unchecked' can save gas by skipping overflow checks. Which snippet correctly applies 'unchecked' to increment a storage variable?

A unchecked { count += 1; }

B count += unchecked(1);

C unchecked count += 1;

D count = unchecked(count + 1);

💡 Hint

Remember the syntax for the 'unchecked' block in Solidity.

'unchecked' is a block statement in Solidity. The correct syntax is 'unchecked { ... }'. Other forms are invalid.

🚀 Application

expert

Optimize storage usage in a struct array

You have a struct with multiple small variables stored in an array. How can you optimize gas usage when updating one field of a struct in storage?

A Delete the struct from storage and recreate it with updated values.

B Update the field directly in storage multiple times to ensure correctness.

C Load the struct into memory, update the field, then write the entire struct back to storage once.

D Use a mapping instead of an array to avoid storage costs.

💡 Hint

Think about minimizing the number of storage writes.

Reading the struct once into memory, updating fields there, and writing back once reduces multiple expensive storage writes, saving gas.