Gas usage testing in Blockchain / Solidity - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Gas usage of simple storage update

Consider a smart contract function that updates a stored number. What is the gas usage behavior when calling this function multiple times with the same value?

Blockchain / Solidity

contract SimpleStorage {
    uint256 public storedData;

    function set(uint256 x) public {
        storedData = x;
    }
}

A Gas cost is zero for calls with the same value as the current storedData.

B Gas cost is the same for every call regardless of the value.

C Gas cost is high only on the first update; subsequent calls with the same value cost less gas.

D Gas cost increases with each call regardless of the value.

💡 Hint

Think about how Ethereum refunds gas when storage is not changed.

When the stored value changes, gas is spent to update storage. If the value is the same, less gas is used because no storage slot is modified.

❓ Predict Output

intermediate

Gas cost of adding vs removing elements in a mapping

Given a mapping in a smart contract, what happens to gas usage when you add a new key-value pair versus when you delete a key?

Blockchain / Solidity

contract MapExample {
    mapping(address => uint256) public balances;

    function addBalance(address user, uint256 amount) public {
        balances[user] = amount;
    }

    function removeBalance(address user) public {
        delete balances[user];
    }
}

A Deleting a key costs more gas than adding one.

B Adding and deleting keys cost the same gas with no refunds.

C Neither adding nor deleting keys affects gas usage.

D Adding a new key costs more gas; deleting a key refunds some gas.

💡 Hint

Consider how storage refunds work in Ethereum.

Adding a new key writes to storage and costs gas. Deleting a key frees storage and refunds gas to the caller.

🔧 Debug

advanced

Unexpected high gas usage in loop

This contract function loops over an array and updates a mapping. Why does it consume unexpectedly high gas?

Blockchain / Solidity

contract LoopGas {
    mapping(uint256 => uint256) public data;
    uint256[] public keys;

    function updateData() public {
        for (uint i = 0; i < keys.length; i++) {
            data[keys[i]] = i;
        }
    }
}

A The mapping update inside the loop is free and does not affect gas.

B The loop condition uses <= which causes an out-of-bounds access and wastes gas.

C The keys array is empty, so the loop does not run and gas is wasted.

D The function is missing a payable modifier causing high gas.

💡 Hint

Check the loop boundary carefully.

Using <= in the loop condition causes the loop to run one extra time, accessing keys[keys.length], which is out-of-bounds and wastes gas.

📝 Syntax

advanced

Gas optimization with unchecked arithmetic

Which option correctly uses unchecked arithmetic to save gas in Solidity 0.8+ without causing overflow errors?

Blockchain / Solidity

function sum(uint256 a, uint256 b) public pure returns (uint256) {
    // Fill in the blank
}

A unchecked { return a + b; }

B return a + b; // no unchecked block

C unchecked return a + b;

D return unchecked(a + b);

💡 Hint

The unchecked block disables overflow checks inside it.

In Solidity 0.8+, arithmetic operations check for overflow by default. Wrapping the operation in an unchecked block disables this check and saves gas.

🚀 Application

expert

Estimating gas cost for dynamic array resizing

You have a function that appends elements to a dynamic array in a smart contract. How does the gas cost behave as the array grows, and which option best describes this behavior?

Blockchain / Solidity

contract DynamicArray {
    uint256[] public numbers;

    function addNumber(uint256 num) public {
        numbers.push(num);
    }
}

A Gas cost per push remains roughly constant regardless of array size.

B Gas cost per push increases linearly as the array grows.

C Gas cost per push decreases as the array grows due to storage optimization.

D Gas cost per push is zero after the first element is added.

💡 Hint

Think about how storage slots are allocated for dynamic arrays.

Each push writes to a new storage slot, so gas cost per push stays roughly constant regardless of array length.