rust-quiz.md

Rust (Programming Language)

Q1. Which type cast preserves the mathematical value in all cases?

• i64 as i32
• usize as u64
• i32 as i64
• f64 as f32

Q2. What do the vertical bars represent here?

str::thread::spawn(|| {
    println!("LinkedIn");
});

• a closure
• a thread
• a future
• a block

reference

Q3. Which choice is not a scalar data type?

• integer
• float
• boolean
• tuple

Q4. _ cannot be destructured.

• Traits
• Tuples
• Enums
• Structs

reference

Q5. Which cargo command checks a program for error without creating a binary executable?

• cargo --version
• cargo init
• cargo build
• cargo check

Q6. The term box and related phrases such as boxing a value are often used when relating to memory layout. What does box refer to?

• It's creating a pointer on the heap that points to a value on the stack.
• It's creating a pointer on the stack that points to a value on the heap.
• It's creating a memory guard around values to prevent illegal access.
• It's an abstraction that refers to ownership. "Boxed" values are clearly labelled.

Q7. What is an alternative way of writing slice that produces the same result?

...
let s = String::form("hello");
let slice = &s[0..2];

• let slice = &s[len + 2];
• let slice = &s[len - 2];
• let slice = &s.copy(0..2);
• let slice = &s[..2];

Q8. Using the ? operator at the end of an expression is equivalent to _.

• a match pattern that branches into True or False
• calling ok_error()
• calling panic!()
• a match pattern that may result an early return

Q9. Which is valid syntax for defining an array of i32 values?

• Array::with_capacity(10)
• [i32]
• Array::new(10)
• [i32; 10]

Q10. What syntax is required to take a mutable reference to T, when used within a function argument?

fn increment(i: T) {
    // body elided
}

• *mut T
• mut ref T
• mut &T
• &mut T

Q11. The smart pointers Rc and Arc provide reference counting. What is the API for incrementing a reference count?

• .add()
• .incr()
• .clone()
• .increment()

reference

Q12. What happens when an error occurs that is being handled by the question mark (?) operator?

• The error is reported and execution continues.
• An exception is raised. The effect(s) of the exception are defined by the error! macro.
• The program panics immediately.
• Rust attempts to convert the error to the local function's error type and return it as Result::Err. If that fails, the program panics.

Q13. Which comment syntax is not legal?

• /*
• #
• //!
• //

Q14. In matching patterns, values are ignored with _.

• .ignore()
• an underscore (_)
• ..
• skip

Q15. Defining a _ requires a lifetime parameter.

• function that ends the lifetime of one of its arguments
• struct that contains a reference to a value
• function with a generic argument
• struct that contains a reference to a boxed value

Rust book reference

Q16. Which example correctly uses std::collections::HashMap's Entry API to populate counts?

use std::collections::HashMap;
fn main() {
    let mut counts = HashMap::new();
    let text = "LinkedIn Learning";
    for c in text.chars() {
        // Complete this block
    }
    println!("{:?}", counts);
}

• [ ]

for c in text.chars() {
    if let Some(count) = &mut counts.get(&c) {
        counts.insert(c, *count + 1);
    } else {
        counts.insert(c, 1);
    };
}

• [x]

for c in text.chars() {
    let count = counts.entry(c).or_insert(0);
    *count += 1;
}

• [ ]

for c in text.chars() {
    let count = counts.entry(c);
    *count += 1;
}

• [ ]

for c in text.chars() {
    counts.entry(c).or_insert(0).map(|x| x + 1);
}

reference

Q17. Which fragment does not incur memory allocations while writing to a "file" (represented by a Vec)?

use std::collections::HashMap;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut v = Vec::<u8>::new();

    let a = "LinkedIn";
    let b = 123;
    let c = '🧀';

    // replace this line

    println!("{:?}", v);

    Ok(())
}

• :

write!(&mut v, "{}{}{}", a, b, c)?;

• :

v.write(a)?;
v.write(b)?;
v.write(c)?;

• :

v.write(a, b, c)?;

• :

v.write_all(a.as_bytes())?;
v.write_all(&b.to_string().as_bytes())?;
c.encode_utf8(&mut v);

1. Answered in rust user forum
2. reference

Q18. Does the main function compile? If so, why? If not, what do you need to change?

fn main() {
    let Some(x) = some_option_value;
}

• The code does not compile. let statements require a refutable pattern. Add if before let.
• The code compiles. let statements sometimes require a refutable pattern.
• The code does not compile. let statements requires an irrefutable pattern. Add if before let.
• The code compiles. let do not require a refutable pattern.

Q19. Which statement about lifetimes is false?

• Lifetimes were redundantly specified in previous version of Rust.
• Lifetimes are specified when a struct is holding a reference to a value.
• Lifetimes are specified when certain values must outlive others.
• Lifetimes are always inferred by the compiler.

Q20. When used as a return type, which Rust type plays a similar role to Python's None, JavaScript's null, or the void type in C/C++?

• !
• None
• Null
• ()

Q21. To convert a Result to an Option, which method should you use?

• .as_option()
• .ok()
• .to_option()
• .into()

Q22. Which statement about the Clone and Copy traits is false?

• Copy is enabled for primitive, built-in types.
• Without Copy, Rust applies move semantics to a type's access.
• When using Clone, copying data is explicit.
• Until a type implements either Copy or Clone, its internal data cannot be copied.

ref from stack overflow

Q23. Why does this code not compile?

fn returns_closure() -> dyn Fn(i32) -> i32 {
    |x| x + 1
}

• The returned fn pointer and value need to be represented by another trait.
• Closures are types, so they cannot be returned directly from a function.
• Closures are types and can be returned only if the concrete trait is implemented.
• Closures are represented by traits, so they cannot be a return type.

Rust book reference

Q24. What smart pointer is used to allow multiple ownership of a value in various threads?

• Arc<T>
• Box<T>
• Both Arc<T> and Rc<T> are multithread safe.
• Rc<T>

Rust book reference

Q25. Which types are not allowed within an enum variant's body?

• zero-sized types
• structs
• trait objects
• floating-point numbers

Reference

Q26. Which statement about this code is true?

fn main() {
    let c = 'z';
    let heart_eyed_cat = '😻';
}

• Both are character literals.
• heart_eyed_cat is an invalid expression.
• c is a string literal and heart_eyed_cat is a character literal.
• Both are string literals.

Reference

Q27. Your application requires a single copy of some data type T to be held in memory that can be accessed by multiple threads. What is the thread-safe wrapper type?

• Mutex<Arc<T>>
• Rc<Mutex<T>>
• Arc<Mutex<T>>
• Mutex<Rc<T>>

Rust book reference

Q28. Which idiom can be used to concatenate the strings a, b, c?

let a = "a".to_string();
let b = "b".to_string();
let c = "c".to_string();

• String::from(a,b,c)
• format!("{}{}{}", a, b, c)
• concat(a,b,c)
• a + b + c

Q29. In this function. what level of access is provided to the variable a?

use std::fmt::Debug;

fn report<T:Debug>(a: &T) {
    eprintln!("info: {:?}", a);
}

• print
• read-only
• read/write
• debug

Q30. Which choice is not valid loop syntax?

• loop
• for
• while
• do

Q31. How do you construct a value of Status that is initialized to Waiting?

enum Status {
    Waiting,
    Busy,
    Error(String),
}

• let s = Enum::new(Status::Waiting);
• let s = new Status::Waiting;
• let s = Status::Waiting;
• let s = Status::new(Waiting);

Q32. Which statement about enums is false?

• Enums are useful in matching patterns.
• Option is an enum type.
• Enum variants can have different types with associated data.
• the term enum is short for enummap

Q33. What does an underscore (_) indicate when used as pattern?

• It matches everything.
• It matches underscores.
• It matches any value that has a length of 1.
• It matches nothing.

Q34. What is a safe operation on a std::cell:UnsafeCell<T>?

• A &mut T reference is allowed. However it may not cpexists with any other references. and may be created only in single-threaded code.
• UnsafeCell<T> provides thread-safety. Therefore, creating &T references from multiple threads is safe.
• The only safe operation is the .get() method, which returns only a raw pointer.
• Non. UnsafeCell<T> only allows code that would otherwise need unsafe blocks to be written in safe code.

Reference

Q35. Generics are useful when you _.

• need to reduce code duplication by concretizing values and restricting parameters in functions
• need to reduce code duplication by abstracting values further, such as in function parameters
• need a supertrait
• are not sure if you need a specific kind of trait

Q36. How do you create a Rust project on the command-line?

• cargo new
• rustup init
• cargo start
• rust new-project

Q37. Calling.clone() _.

• deeply copies heap data and clones ownership
• clones the pointer to the heap
• clones the heap data onto the stack
• deeply copies heap and stack

Reference

Q38. what is one of the roles of the let keyword?

let text = String::new("LinkedIn");

• Create a text object.
• Assign a mutable value.
• request to borrow a string.
• Assign an immutable value.

Reference

Q39. How is a new enum initialized?

enum Option_i32 {
    Some(i32),
    None,
}

• let integer = Option_i32::Some(5);
• let integer = Option_i32.new(Some(5))
• let integer = Option_i32::New::(Some(5))
• let integer = Option_i32.init()

Reference

Q40. What are the main difference between const and static?

• They can be used interchangeably, but const only supports primitive types while static must be used for structs and user-defined types.
• They can be used interchangeably, but const values are compiled at compile time.
• Values defined with const live in the stack, while static values live on the heap.
• Values defined with const can be copied to wherever they are needed, whereas static values remain in a fixed place in memory.

Reference

Q41. Which Rust data type represents a signed integer that has the same width as a pointer of the compile target's CPU?

• i64
• int64
• isize
• int

Reference

Q42. When are supertraits needed?

• when a trait is needed for multiple structs
• when a trait depends on another trait
• only when a generic trait is used
• when a metatrait is needed to use another trait

Reference