Rust Programming Language Skill Assessment Quiz 2022 | LinkedIn Skill Assessment Quiz | LinkedIn | MNC Answers
Disclaimer: The primary purpose of providing this solution is to assist and support anyone who are unable to complete these courses due to a technical issue or a lack of expertise. This website's information or data are solely for the purpose of knowledge and education.
All Question of the MCQs Present Below for Ease Use Ctrl + F with the question name to find the Answer. All the Best!
*****************************************
How to take LinkedIn Skill Assessment- Login in to your 'LinkedIn' profile
- Click on 'Me'
- Click on 'View Profile'
- Scroll to 'Skills' section
- click on 'Take skill quiz'
- Search for your preferred courses/skills and take up the assessment
*******************************************
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
Q3. Which choice is not a scalar data type?
- integer
- float
- boolean
- tuple
_ cannot be destructured.
Q4.- Traits
- Tuples
- Enums
- Structs
cargo
command checks a program for error without creating a binary executable?
Q5. Which - 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.
slice
that produces the same result?
Q7. What is an alternative way of writing ...
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];
?
operator at the end of an expression is equivalent to _.
Q8. Using the - 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()
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 (_)
- .. [answer]
- 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
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);
}
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(())
}
- [x]
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);
main
function compile? If so, why? If not, what do you need to change?
Q18. Does the fn main() {
let Some(x) = some_option_value;
}
- The code does not compile.
let
statements require a refutable pattern. Addif
beforelet
. - The code compiles.
let
statements sometimes require a refutable pattern. - The code does not compile.
let
statements requires an irrefutable pattern. Addif
beforelet
. - 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.
None
, JavaScript's null
, or the void
type in C/C++?
Q20. When used as a return type, which Rust type plays a similar role to Python's -
!
-
None
-
Null
-
()
Result
to an Option
, which method should you use?
Q21. To convert a -
.as_option()
-
.ok()
-
.to_option()
-
.into()
Clone
and Copy
traits is false?
Q22. Which statement about the -
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
orClone
, its internal data cannot be copied.
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.
Q24. What smart pointer is used to allow multiple ownership of a value in various threads?
-
Arc<T>
-
Box<T>
- Both
Arc<T>
andRc<T>
are multithread safe. -
Rc<T>
Q25. Which types are not allowed within an enum variant's body?
- zero-sized types
- structs
- trait objects
- floating-point numbers
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 andheart_eyed_cat
is a character literal. - Both are string literals.
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>>
a
, b
, c
?
Q28. Which idiom can be used to concatenate the strings 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
a
?
Q29. In this function. what level of access is provided to the variable use std::fmt::Debug;
fn report<T:Debug>(a: &T) {
eprintln!("info: {:?}", a);
}
- read-only
- read/write
- debug
Q30. Which choice is not valid loop syntax?
-
loop
-
for
-
while
-
do
Status
that is initialized to Waiting
?
Q31. How do you construct a value of 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.
std::cell:UnsafeCell<T>
?
Q34. What is a safe operation on a - 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.
_.
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
**************************************************Credit for the above notes, goes to the respective owners.If you have any queries, please feel free to ask on the comment section.Please share and support our page!
Post a Comment