Efficient data structures in Blockchain / Solidity - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a mapping in Solidity that links addresses to balances.

Blockchain / Solidity

mapping(address => uint) public [1];

Drag options to blanks, or click blank then click option'

Ausers

Bbalance

Caccounts

Dbalances

Attempts:

3 left

💡 Hint

Common Mistakes

Using singular form like 'balance' which is less common for mappings.

Using unrelated names like 'users' which do not describe balances.

The mapping name balances is commonly used to store user balances in Solidity smart contracts.

2fill in blank

medium

Complete the code to add a new element to a dynamic array in Solidity.

Blockchain / Solidity

uint[] public numbers;

function addNumber(uint num) public {
    numbers.[1](num);
}

Drag options to blanks, or click blank then click option'

Aappend

Binsert

Cpush

Dadd

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'append' which is a Python method, not Solidity.

Using 'insert' which requires an index in Solidity.

The push function adds a new element to the end of a dynamic array in Solidity.

3fill in blank

hard

Fix the error in the code to correctly check if a key exists in a mapping.

Blockchain / Solidity

mapping(address => uint) public balances;

function hasBalance(address user) public view returns (bool) {
    return balances[[1]] != 0;
}

Drag options to blanks, or click blank then click option'

Amsg.sender

Buser

Caddress

Dthis

Attempts:

3 left

💡 Hint

Common Mistakes

Using msg.sender which checks the caller, not the input address.

Using address which is a type, not a variable.

The function parameter user should be used to check the balance in the mapping.

4fill in blank

hard

Fill both blanks to create a struct and declare a mapping from address to that struct.

Blockchain / Solidity

struct [1] {
    uint balance;
    uint lastUpdated;
}

mapping(address => [2]) public accounts;

Drag options to blanks, or click blank then click option'

AAccount

BUser

DBalance

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names for the struct and mapping type.

Using unrelated names like 'Balance' which is a field, not a struct.

The struct is named Account and the mapping uses the same struct type.

5fill in blank

hard

Fill all three blanks to create a mapping with a nested mapping for token balances.

Blockchain / Solidity

mapping(address => mapping([1] => uint)) public [2];

function getBalance(address user, [3] token) public view returns (uint) {
    return [2][user][token];
}

Drag options to blanks, or click blank then click option'

Aaddress

Bbalances

Dtokens

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect key types like 'uint' for tokens.

Using inconsistent names for the mapping and function parameters.

The nested mapping uses address as the key type for tokens, the mapping is named balances, and the function parameter for token is an address.

Practice

1. Which data structure is best for quickly finding a user's balance by their blockchain address?

easy

A. Array

B. Mapping (key-value pairs)

C. Struct

D. Linked list

Solution

1. Step 1: Understand the need for quick lookup

   We want to find a balance by address fast, so we need a structure that supports direct access by key.

2. Step 2: Identify the best data structure

   Mappings provide key-value pairs allowing O(1) access by address, unlike arrays or structs which require searching.

3. Final Answer:

   Mapping (key-value pairs) -> Option B

4. Quick Check:

   Fast key-based lookup = Mapping [OK]

Hint: Use mappings for direct key lookups in blockchain [OK]

Common Mistakes:

• Choosing arrays which require looping to find an address
• Using structs alone without a key for lookup
• Thinking linked lists are efficient for random access

2. Which of the following is the correct syntax to declare a mapping from address to uint in Solidity?

easy

A. mapping(address => uint) balances;

B. mapping(address, uint) balances;

C. mapping[address] uint balances;

D. mapping{address: uint} balances;

Solution

1. Step 1: Recall Solidity mapping syntax

   Mappings use the syntax mapping(keyType => valueType) variableName;

2. Step 2: Match the correct syntax

   mapping(address => uint) balances; matches this exactly: mapping(address => uint) balances;

3. Final Answer:

   mapping(address => uint) balances; -> Option A

4. Quick Check:

   Correct mapping syntax uses '=>' [OK]

Hint: Remember mapping uses '=>' between key and value types [OK]

Common Mistakes:

• Using commas instead of '=>' in mapping
• Using square brackets or curly braces incorrectly
• Omitting the semicolon at the end

3. What will be the output of this Solidity code snippet?

struct User { uint id; string name; }
User[] users;
users.push(User(1, "Alice"));
users.push(User(2, "Bob"));
string memory name = users[1].name;

medium

A. "Alice"

B. Empty string

C. Compilation error

D. "Bob"

Solution

1. Step 1: Understand array indexing

   Arrays start at index 0, so users[0] is Alice, users[1] is Bob.

2. Step 2: Identify the accessed element

   The code accesses users[1].name, which is "Bob".

3. Final Answer:

   "Bob" -> Option D

4. Quick Check:

   Index 1 in array = "Bob" [OK]

Hint: Remember arrays start at zero index [OK]

Common Mistakes:

• Confusing index 1 with index 0
• Assuming structs print as variable names
• Expecting compilation error due to string usage

4. Identify the error in this Solidity code snippet:

mapping(address => uint) balances;
function addBalance(address user, uint amount) public {
  balances[user] += amount;
}

medium

A. Cannot use '+=' on mapping values

B. Function lacks visibility modifier

C. No initialization needed for mapping values

D. Mapping keys must be uint, not address

Solution

1. Step 1: Check mapping usage

   Mappings default to zero for uint values if key not set, so no initialization needed.

2. Step 2: Verify function and operation

   Using '+=' on balances[user] is valid; function has public visibility.

3. Final Answer:

   No initialization needed for mapping values -> Option C

4. Quick Check:

   Mapping uint defaults to 0, so '+=' works [OK]

Hint: Mapping values default to zero, no init needed [OK]

Common Mistakes:

• Thinking mapping values must be initialized before use
• Confusing visibility modifiers
• Assuming keys must be uint instead of address

5. You want to store user profiles with id, name, and balance, and quickly find a profile by id. Which data structure combination is most efficient in Solidity?

hard

A. Mapping from id to struct

B. Array of structs only

C. Struct with embedded array

D. Linked list of structs

Solution

1. Step 1: Analyze the need for quick lookup by id

   Quick lookup by id requires direct access, which arrays or linked lists cannot provide efficiently.

2. Step 2: Choose the best data structure

   Mapping from id to struct allows O(1) access to user profiles by id, combining grouping (struct) and fast lookup (mapping).

3. Final Answer:

   Mapping from id to struct -> Option A

4. Quick Check:

   Fast key access + grouped data = mapping to struct [OK]

Hint: Use mapping from id to struct for fast profile lookup [OK]

Common Mistakes:

• Using arrays which require looping to find id
• Using linked lists which are slow for random access
• Embedding arrays inside structs without mapping