Constants in Rust - Time & Space Complexity

Time Complexity: Constants

O(1)

Understanding Time Complexity

When using constants in Rust, it's important to see how they affect the speed of a program.

We want to know how the program's running time changes as input grows when constants are involved.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

const MAX: usize = 1000;

fn print_numbers() {
    for i in 0..MAX {
        println!("{}", i);
    }
}
    

This code prints numbers from 0 up to a fixed constant MAX.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: A for-loop running from 0 to MAX.
• How many times: Exactly MAX times, which is a fixed number.

How Execution Grows With Input

Explain the growth pattern intuitively.

Input Size (n)	Approx. Operations
10	1000 (constant)
100	1000 (constant)
1000	1000 (constant)

Pattern observation: The number of operations stays the same no matter how input changes because MAX is fixed.

Final Time Complexity

Time Complexity: O(1)

This means the running time does not grow with input size; it stays constant.

Common Mistake

[X] Wrong: "Since there is a loop, the time must grow with input size."

[OK] Correct: The loop runs a fixed number of times set by a constant, so it does not depend on input size.

Interview Connect

Understanding constants helps you explain why some parts of code run quickly no matter the input size, a useful skill in interviews.

Self-Check

"What if MAX was a variable input instead of a constant? How would the time complexity change?"

Practice

1. What is true about constants in Rust?

easy

A. Constants can be changed anytime during program execution.

B. Constants must have a type and cannot be changed after declaration.

C. Constants do not require a type annotation.

D. Constants are only used inside functions.

Solution

1. Step 1: Understand constant properties in Rust

   Constants in Rust must have an explicit type and are immutable by design.

2. Step 2: Evaluate each option

   Constants must have a type and cannot be changed after declaration correctly states constants require a type and cannot change. The other options are incorrect because constants cannot be changed anytime during execution, they must have a type annotation, and they can be declared outside functions.

3. Final Answer:

   Constants must have a type and cannot be changed after declaration. -> Option B

4. Quick Check:

   Constants are immutable with explicit types = B [OK]

Hint: Constants always need a type and never change [OK]

Common Mistakes:

• Thinking constants can be changed like variables
• Omitting the type annotation for constants
• Assuming constants are only for inside functions

2. Which of the following is the correct syntax to declare a constant named MAX_POINTS with value 100 in Rust?

easy

A. const MAX_POINTS = 100;

B. var MAX_POINTS: i32 = 100;

C. let MAX_POINTS: i32 = 100;

D. const MAX_POINTS: i32 = 100;

Solution

1. Step 1: Recall Rust constant syntax

   Constants use the keyword const, require a type annotation, and use an equals sign to assign a value.

2. Step 2: Check each option

   const MAX_POINTS: i32 = 100; matches the correct syntax: const MAX_POINTS: i32 = 100;. const MAX_POINTS = 100; misses the type, var MAX_POINTS: i32 = 100; uses invalid keyword var, let MAX_POINTS: i32 = 100; uses let for variables.

3. Final Answer:

   const MAX_POINTS: i32 = 100; -> Option D

4. Quick Check:

   Constants need const + type + value = D [OK]

Hint: Use const with type and value for constants [OK]

Common Mistakes:

• Forgetting the type annotation
• Using let or var instead of const
• Missing the semicolon at the end

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

const PI: f64 = 3.14;
fn main() {
    println!("Value of PI is {}", PI);
}

medium

A. Value of PI is 3.14

B. Value of PI is PI

C. Compile error: missing type for PI

D. Runtime error

Solution

1. Step 1: Understand constant declaration and usage

   The constant PI is declared with type f64 and value 3.14. It is used inside println! macro.

2. Step 2: Predict output of the print statement

   The print statement will replace {} with the value of PI, which is 3.14. No errors occur.

3. Final Answer:

   Value of PI is 3.14 -> Option A

4. Quick Check:

   Printing constant value outputs its assigned number = A [OK]

Hint: Constants print their value directly in output [OK]

Common Mistakes:

• Expecting the name 'PI' to print instead of its value
• Thinking missing type causes error here (type is given)
• Confusing runtime errors with compile-time constants

4. Identify the error in this Rust code:

const MAX: i32 = 10;
fn main() {
    MAX = 20;
    println!("{}", MAX);
}

medium

A. Constants cannot be used inside functions.

B. Missing semicolon after constant declaration.

C. Cannot assign a new value to a constant after declaration.

D. The println! macro is used incorrectly.

Solution

1. Step 1: Analyze constant assignment

   Constants in Rust are immutable and cannot be assigned a new value after declaration.

2. Step 2: Check the code for errors

   The line MAX = 20; tries to change the constant, which causes a compile-time error.

3. Final Answer:

   Cannot assign a new value to a constant after declaration. -> Option C

4. Quick Check:

   Constants are immutable; reassignment causes error = C [OK]

Hint: Constants cannot be reassigned after declaration [OK]

Common Mistakes:

• Trying to change a constant's value
• Thinking constants behave like variables
• Ignoring compiler error messages about immutability

5. You want to define a constant for the number of days in a week and use it in a function to calculate total days for given weeks. Which code correctly uses constants in Rust?

hard

A. const DAYS_IN_WEEK: u32 = 7;
fn total_days(weeks: u32) -> u32 {
weeks * DAYS_IN_WEEK
}

B. let DAYS_IN_WEEK = 7;
fn total_days(weeks: u32) -> u32 {
weeks * DAYS_IN_WEEK
}

C. const DAYS_IN_WEEK = 7;
fn total_days(weeks: u32) -> u32 {
weeks * DAYS_IN_WEEK
}

D. static DAYS_IN_WEEK: u32 = 7;
fn total_days(weeks: u32) -> u32 {
weeks + DAYS_IN_WEEK
}

Solution

1. Step 1: Check constant declaration correctness

   const DAYS_IN_WEEK: u32 = 7; fn total_days(weeks: u32) -> u32 { weeks * DAYS_IN_WEEK } declares a constant with type u32 and value 7, which is correct syntax.

2. Step 2: Verify usage in function

   The function multiplies weeks by the constant, correctly calculating total days. let DAYS_IN_WEEK = 7; fn total_days(weeks: u32) -> u32 { weeks * DAYS_IN_WEEK } uses let which is not a constant. const DAYS_IN_WEEK = 7; fn total_days(weeks: u32) -> u32 { weeks * DAYS_IN_WEEK } misses the type annotation. static DAYS_IN_WEEK: u32 = 7; fn total_days(weeks: u32) -> u32 { weeks + DAYS_IN_WEEK } uses static and adds weeks and days, which is incorrect logic.

3. Final Answer:

   const DAYS_IN_WEEK: u32 = 7; fn total_days(weeks: u32) -> u32 { weeks * DAYS_IN_WEEK } -> Option A

4. Quick Check:

   Correct const declaration and usage in calculation = A [OK]

Hint: Use const with type and multiply correctly in function [OK]

Common Mistakes:

• Using let instead of const for fixed values
• Omitting type annotation in const declaration
• Using addition instead of multiplication for total days