Program structure in Rust - Time & Space Complexity

Time Complexity: Program structure in Rust

O(n)

Understanding Time Complexity

When we look at how a Rust program is built, we want to know how the time it takes to run changes as the program grows.

We ask: How does the program's structure affect how long it runs?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];
    for num in &numbers {
        println!("Number: {}", num);
    }
}

This code creates a list of numbers and prints each one.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Looping through the list to print each number.
• How many times: Once for each number in the list.

How Execution Grows With Input

As the list gets bigger, the program prints more numbers, so it takes more time.

Input Size (n)	Approx. Operations
10	10 print actions
100	100 print actions
1000	1000 print actions

Pattern observation: The time grows directly with the number of items.

Final Time Complexity

Time Complexity: O(n)

This means the time to run grows in a straight line with the number of items.

Common Mistake

[X] Wrong: "The program runs in the same time no matter how many numbers there are."

[OK] Correct: Because the program prints each number, more numbers mean more work and more time.

Interview Connect

Understanding how loops affect time helps you explain how your code will behave as data grows, a key skill in programming.

Self-Check

"What if we added another loop inside the first one to print pairs of numbers? How would the time complexity change?"

Practice

1. In a Rust program, where does the execution start?

easy

A. At the last line of the file

B. Inside the main function

C. Inside a function named start

D. At the first line of the file outside any function

Solution

1. Step 1: Understand Rust program entry point

   Rust programs always begin execution from the main function.

2. Step 2: Check other options

   Code outside functions or other function names like start are not entry points.

3. Final Answer:

   Inside the main function -> Option B

4. Quick Check:

   Rust starts at main() [OK]

Hint: Rust always runs code starting from main() [OK]

Common Mistakes:

• Thinking code outside main() runs first
• Assuming a function named start() runs automatically
• Believing execution starts at the last line

2. Which of the following is the correct way to write the main function in Rust?

easy

A. function main() { println!("Hello, world!"); }

B. main() { println!("Hello, world!"); }

C. fn main() { println!("Hello, world!"); }

D. def main() { println!("Hello, world!"); }

Solution

1. Step 1: Identify Rust function syntax

   Rust functions start with fn, followed by the name and parentheses.

2. Step 2: Check each option

   Only fn main() { println!("Hello, world!"); } uses fn main() correctly; others use wrong keywords.

3. Final Answer:

   fn main() { println!("Hello, world!"); } -> Option C

4. Quick Check:

   Rust functions start with fn [OK]

Hint: Rust functions start with fn keyword [OK]

Common Mistakes:

• Using function or def instead of fn
• Omitting fn keyword
• Missing parentheses after function name

3. What will be the output of this Rust program?

fn main() {
    println!("Start");
    {
        println!("Inside block");
    }
    println!("End");
}

medium

A. Start\nInside block\nEnd

B. Start\nEnd\nInside block

C. Inside block\nStart\nEnd

D. Start\nInside block

Solution

1. Step 1: Follow the code execution order

   The program prints "Start", then enters the block and prints "Inside block", then prints "End" after the block.

2. Step 2: Confirm output sequence

   The output lines appear in the order: Start, Inside block, End.

3. Final Answer:

   Start\nInside block\nEnd -> Option A

4. Quick Check:

   Code runs top to bottom inside blocks [OK]

Hint: Code runs step by step inside braces [OK]

Common Mistakes:

• Assuming block runs after all code
• Mixing order of print statements
• Ignoring braces as code grouping

4. Identify the error in this Rust program:

fn main() {
    println!("Hello");
    // Missing closing brace

medium

A. println! macro is misspelled

B. Missing semicolon after println!

C. Incorrect comment syntax

D. Missing closing brace '}' for main function

Solution

1. Step 1: Check code structure

   The main function starts with fn main() { but never closes with a }.

2. Step 2: Verify other syntax

   The semicolon after println! is present, comment syntax is correct, and println! is spelled correctly.

3. Final Answer:

   Missing closing brace '}' for main function -> Option D

4. Quick Check:

   Every { needs a matching } [OK]

Hint: Count opening and closing braces carefully [OK]

Common Mistakes:

• Forgetting to close function with }
• Confusing comment syntax with errors
• Missing semicolon errors instead of braces

5. You want to add a comment explaining why your Rust program prints "Hello". Which is the correct way to add a single-line comment inside the main function?

hard

A. // This prints Hello
println!("Hello");

B. # This prints Hello
println!("Hello");

C. /* This prints Hello */ println!("Hello");

D. println!("Hello");

Solution

1. Step 1: Identify Rust comment syntax

   Rust uses // for single-line comments and /* */ for block comments.

2. Step 2: Check each option

   Only // This prints Hello println!("Hello"); uses Rust's single-line comment syntax correctly; /* ... */ is a block comment, # is Python-style, and <!-- ... --> is HTML.

3. Final Answer:

   // This prints Hello println!("Hello"); -> Option A

4. Quick Check:

   Single-line comments start with // [OK]

Hint: Use // for single-line comments in Rust [OK]

Common Mistakes:

• Using # or for comments
• Confusing block comments with single-line
• Placing comments inside println! macro