Constants in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of constant usage in Rust

What is the output of this Rust program that uses a constant?

Rust

const MAX_POINTS: u32 = 100_000;

fn main() {
    println!("Max points: {}", MAX_POINTS);
}

A Max points: 100_000

B Compilation error: constants must be mutable

C Max points: 100000

D Runtime error: constant not initialized

💡 Hint

Constants in Rust are immutable and can be used anywhere after declaration.

The constant MAX_POINTS is set to 100_000, which is just a numeric literal with an underscore for readability. The program prints the value as 100000 without underscores.

❓ Predict Output

intermediate

Constant shadowing and output

What will this Rust code print when run?

Rust

const VALUE: i32 = 10;

fn main() {
    let VALUE = 20;
    println!("Value is: {}", VALUE);
}

A Value is: 20

B Runtime error: variable VALUE not found

C Compilation error: cannot shadow constant

D Value is: 10

💡 Hint

Local variables can shadow constants with the same name.

The local variable VALUE shadows the constant VALUE inside main, so the printed value is 20.

❓ Predict Output

advanced

Constant expression evaluation

What is the output of this Rust program using constant expressions?

Rust

const BASE: u32 = 5;
const MULTIPLIER: u32 = 3;
const RESULT: u32 = BASE * MULTIPLIER;

fn main() {
    println!("Result: {}", RESULT);
}

A Compilation error: cannot multiply constants

B Result: 15

C Result: 8

D Runtime error: constant not initialized

💡 Hint

Constants can be computed at compile time using expressions.

The constant RESULT is computed as 5 * 3 = 15 at compile time and printed.

❓ Predict Output

advanced

Constant type mismatch error

What error does this Rust code produce?

Rust

const PI: f32 = 3.14;
const RADIUS: u32 = 5;
const AREA: u32 = PI * RADIUS * RADIUS;

fn main() {
    println!("Area: {}", AREA);
}

A Compilation error: mismatched types between f32 and u32

B Area: 78

C Runtime error: cannot multiply float and integer

D Compilation error: constant AREA not initialized

💡 Hint

Rust requires matching types in constant expressions.

The constant AREA tries to multiply a float (PI) with integers (RADIUS), causing a type mismatch error at compile time.

🧠 Conceptual

expert

Why use constants instead of variables in Rust?

Which of the following is the best reason to use a constant instead of a variable in Rust?

A Constants allow you to use mutable references safely

B Constants can be changed at runtime for flexibility

C Constants are faster because they are stored on the heap

D Constants guarantee immutability and can be used in any scope without allocation

💡 Hint

Think about immutability and compile-time guarantees.

Constants in Rust are immutable, have no fixed memory address, and can be used anywhere without runtime overhead, unlike variables.

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