Why Solidity is the language of Ethereum in Blockchain / Solidity - Performance Analysis

Time Complexity: Why Solidity is the language of Ethereum

O(n)

Understanding Time Complexity

When we look at Solidity, the main language for Ethereum smart contracts, it's important to understand how the time it takes to run code grows as the contract handles more data or users.

We want to see how Solidity's design affects the speed and cost of running Ethereum programs.

Scenario Under Consideration

Analyze the time complexity of a simple Solidity function that loops through an array of addresses to find a specific one.

contract SimpleSearch {
    address[] public users;

    function findUser(address target) public view returns (bool) {
        for (uint i = 0; i < users.length; i++) {
            if (users[i] == target) {
                return true;
            }
        }
        return false;
    }
}
    

This code checks if a given address is in the users list by checking each one in order.

Identify Repeating Operations

Look for parts that repeat as the input grows.

• Primary operation: The for-loop that checks each user address one by one.
• How many times: It runs once for each user in the list until it finds the target or finishes the list.

How Execution Grows With Input

As the number of users grows, the time to find a user grows too.

Input Size (n)	Approx. Operations
10	Up to 10 checks
100	Up to 100 checks
1000	Up to 1000 checks

Pattern observation: The time grows roughly in direct proportion to the number of users.

Final Time Complexity

Time Complexity: O(n)

This means the time to run the function grows linearly with the number of users in the list.

Common Mistake

[X] Wrong: "The function always runs in the same time no matter how many users there are."

[OK] Correct: The function may stop early if it finds the user, but in the worst case it checks every user, so time grows with the list size.

Interview Connect

Understanding how Solidity code runs as data grows helps you write efficient smart contracts and shows you know how to think about performance in blockchain programming.

Self-Check

"What if we used a mapping instead of an array to store users? How would the time complexity change?"