Floating point types in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust code using f32?

Consider the following Rust code snippet. What will it print?

Rust

fn main() {
    let x: f32 = 0.1 + 0.2;
    println!("{:.8}", x);
}

A 0.30000001

B 0.3

C 0.4

D 0.2

💡 Hint

Remember that floating point numbers can have precision errors.

Adding 0.1 and 0.2 in f32 does not exactly equal 0.3 due to floating point precision. The printed value is slightly off, like 0.30000001.

🧠 Conceptual

intermediate

Which floating point type has higher precision in Rust?

Between f32 and f64 in Rust, which one provides higher precision?

A Both have the same precision

B f64 has higher precision

C f32 has higher precision

D Precision depends on the CPU architecture

💡 Hint

Think about the number of bits used to store each type.

f64 uses 64 bits and provides higher precision than f32, which uses 32 bits.

🔧 Debug

advanced

Why does this Rust code cause a compilation error?

Look at this Rust code snippet. Why does it fail to compile?

Rust

fn main() {
    let x: f32 = 1.0;
    let y: f64 = 2.0;
    let z = x + y;
    println!("{}", z);
}

A f32 and f64 cannot be declared in the same function

B Variables x and y must be mutable to add

C The println! macro does not support floating point numbers

D Cannot add f32 and f64 directly without casting

💡 Hint

Check the types involved in the addition operation.

Rust does not allow adding f32 and f64 directly. You must cast one type to the other before adding.

📝 Syntax

advanced

Which Rust code correctly declares a 64-bit floating point variable?

Choose the correct Rust syntax to declare a variable pi as a 64-bit floating point number with value 3.1415.

A let pi: float64 = 3.1415;

B let pi = 3.1415f32;

C let pi: f64 = 3.1415;

D let pi = f64(3.1415);

💡 Hint

Look at the correct Rust type name for 64-bit floats.

In Rust, f64 is the correct type for 64-bit floating point numbers. The syntax let pi: f64 = 3.1415; is correct.

🚀 Application

expert

What is the value of variable `result` after this Rust code runs?

Analyze the following Rust code and determine the value of result after execution.

Rust

fn main() {
    let a: f64 = 0.1;
    let b: f64 = 0.2;
    let c = a + b;
    let result = (c - 0.3).abs() < 1e-15;
    println!("{}", result);
}

A true

B false

C Compilation error

D Runtime panic

💡 Hint

Consider floating point precision and how to compare floats safely.

The sum a + b is very close to 0.3 but not exactly equal. The code checks if the difference is less than a tiny number, so result is true.