Rust Data Types Quiz

0 Passed

0% acceptance

45 comprehensive questions on Rust's type system, covering scalar types, compound types, type conversions, numeric operations, and string types — with 15 code examples demonstrating practical type usage patterns.

45 Questions

~90 minutes

Question 1

What are the four primary scalar types in Rust?

integers, floating-point numbers, booleans, and characters

strings, arrays, tuples, and structs

i32, f64, bool, and char

signed, unsigned, float, and boolean

Question 2

How many bits does an i32 integer type represent?

16 bits

32 bits

64 bits

8 bits

Question 3

What is the default integer type in Rust when you don't specify one?

i32

i64

usize

Question 4

What happens when you try to add two different integer types without explicit conversion?

The operation succeeds with automatic conversion

Compilation error: mismatched types

Runtime error

The smaller type is promoted to the larger type

Question 5

Which of these is a valid floating-point literal in Rust?

3.14159

3.14159f32

Both A and B

Neither is valid

Question 6

What is the difference between f32 and f64 floating-point types?

f32 is single precision (32 bits), f64 is double precision (64 bits)

f32 is faster, f64 is more precise

f64 is the default for literals

All of the above

Question 7

How do you represent a single character in Rust?

Using single quotes: 'A'

Using double quotes: "A"

Using backticks: `A`

Characters are not supported

Question 8

What will this code output?

rust

fn main() {
    let c = 'z';
    let z = 'ℤ';
    let heart_eyed_cat = '😻';
    println!("Characters: {}, {}, {}", c, z, heart_eyed_cat);
}

Characters: z, ℤ, 😻

Compilation error

Characters: z, ?, ?

Runtime error

Question 9

What are compound types in Rust?

Types that group multiple values into one type

Types that can be converted automatically

Types that are stored on the heap

Types that cannot be copied

Question 10

How do you declare a tuple in Rust?

let tup: (i32, f64, u8) = (500, 6.4, 1);

let tup = [500, 6.4, 1];

let tup = {500, 6.4, 1};

let tup = <500, 6.4, 1>;

Question 11

How do you access elements of a tuple?

Using dot notation: tuple.0, tuple.1, etc.

Using bracket notation: tuple[0], tuple[1], etc.

Using arrow notation: tuple->0, tuple->1, etc.

Tuples cannot be indexed

Question 12

What is destructuring in the context of tuples?

Breaking a tuple into individual variables

Converting a tuple to an array

Sorting tuple elements

Removing elements from a tuple

Question 13

How do you declare an array in Rust?

let a = [1, 2, 3, 4, 5];

let a: [i32; 5] = [1, 2, 3, 4, 5];

Both A and B are valid

Neither is valid

Question 14

What happens if you try to access an array element beyond its bounds?

The program panics at runtime

Compilation error

Returns a default value

Wraps around to the beginning

Question 15

How do you create an array with the same value repeated?

let a = [3; 5]; // creates [3, 3, 3, 3, 3]

let a = [3].repeat(5);

let a = vec![3; 5];

This is not possible with arrays

Question 16

What is the key difference between arrays and vectors in Rust?

Arrays have fixed size known at compile time, vectors can grow dynamically

Arrays are heap-allocated, vectors are stack-allocated

Vectors are faster than arrays

Arrays can contain different types, vectors cannot

Question 17

How do you perform explicit type conversion (casting) in Rust?

Using the 'as' keyword: value as TargetType

Using parentheses: (TargetType) value

Using angle brackets: <TargetType> value

Automatic conversion happens

Question 18

When building a graphics application that needs to convert floating-point colors to integer pixel values, how should you handle the conversion?

Use 'as' casting: (color * 255.0) as u8

Use automatic conversion

Use a conversion function

This requires unsafe code

Question 19

What happens when you cast a large integer to a smaller type?

The value wraps around (two's complement wrapping)

Compilation error

Runtime panic

The value is truncated

Question 20

What will this code output?

rust

fn main() {
    let decimal = 65.4321_f32;
    let integer = decimal as u8;
    let character = integer as char;
    println!("{} -> {} -> {}", decimal, integer, character);
}

65.4321 -> 65 -> A

Compilation error

65.4321 -> 65 -> ?

Runtime error

Question 21

What are the two main string types in Rust?

String and &str

str and &String

String and string

str and Str

Question 22

What is the difference between String and &str?

String owns its data and can be modified, &str is a reference to existing UTF-8 data

String is stack-allocated, &str is heap-allocated

&str can be modified, String cannot

There is no functional difference

Question 23

How do you create a new String?

String::new() or String::from("text")

let s = "text";

&str::new()

str::from("text")

Question 24

What happens when you try to modify a string literal?

It works because string literals are mutable

Compilation error: string literals are immutable

Runtime error

The literal becomes a String

Question 25

How do you convert a String to a &str?

&string_variable or string_variable.as_str()

string_variable.to_str()

Automatic conversion happens

This conversion is not possible

Question 26

What will this code output?

rust

fn main() {
    let mut s = String::from("Hello");
    s.push_str(", world!");
    println!("{}", s);
}

Hello, world!

Hello

Compilation error

Runtime error

Question 27

How do you concatenate strings in Rust?

Using the + operator or format! macro

Using the & operator

Using the concat! macro

Strings cannot be concatenated

Question 28

What is UTF-8 encoding in the context of Rust strings?

The encoding standard that Rust strings use to represent text

A compression algorithm

A hashing function

A sorting algorithm

Question 29

When processing user input that contains international characters, what should you be aware of?

Rust strings handle UTF-8 automatically, but indexing by bytes vs characters differs

International characters are not supported

You need to convert to ASCII first

Performance is significantly impacted

Question 30

What are the basic arithmetic operations available for numeric types?

Addition (+), subtraction (-), multiplication (*), division (/), remainder (%)

Only addition and subtraction

Only multiplication and division

Arithmetic operations are not supported

Question 31

What happens when integer arithmetic overflows in debug mode?

The program panics

The value wraps around

Compilation error

The operation is ignored

Question 32

How can you explicitly handle integer overflow?

Using methods like checked_add, saturating_add, wrapping_add, overflowing_add

Using unsafe code

Using larger integer types

Overflow cannot be handled explicitly

Question 33

In a financial application where you need to prevent monetary value overflow, which overflow handling method should you use?

checked_add() to detect and handle overflow

wrapping_add() to allow overflow

saturating_add() to clamp at maximum

overflowing_add() for performance

Question 34

What is the difference between f32 and f64 division results?

f64 provides more precision than f32

f32 is faster but less precise

f64 defaults to infinity for division by zero

All of the above

Question 35

How do you access individual bytes of a string?

string.as_bytes()

string.bytes()

Both A and B work

Strings don't have bytes

Question 36

What will this code output?

rust

fn main() {
    let s = "Hello, 世界!";
    println!("Bytes: {:?}", s.as_bytes());
    println!("Length: {}", s.len());
}

Bytes: [72, 101, 108, 108, 111, 44, 32, 228, 189, 160, 231, 149, 140, 33], Length: 13

Bytes: [72, 101, 108, 108, 111, 44, 32, 19990, 30028, 33], Length: 9

Compilation error

Runtime error

Question 37

Why is string indexing by integer potentially dangerous in Rust?

Because UTF-8 characters can be multiple bytes, so s[0] might not be a valid character

Because strings are immutable

Because Rust doesn't support indexing

Because strings are heap-allocated

Question 38

How do you iterate over characters in a string properly?

for c in string.chars() { ... }

for i in 0..string.len() { let c = string[i]; ... }

for c in string { ... }

Characters cannot be iterated

Question 39

When implementing a text processing function that needs to handle international text correctly, what approach should you use?

Use chars() for character-by-character processing

Use byte indexing with bounds checking

Convert to ASCII first

Use unsafe code for performance

Question 40

What is the result of this arithmetic expression?

rust

fn main() {
    let result = 10u32.saturating_add(20u32);
    println!("Result: {}", result);
}

Result: 30

Result: 0 (wrapped)

Compilation error

Runtime panic

Question 41

How do you create a tuple with mixed types?

let mixed = (42, 3.14, true, 'R');

let mixed = [42, 3.14, true, 'R'];

let mixed: (i32, f64, bool, char) = (42, 3.14, true, 'R');

Both A and C are valid

Question 42

What happens when you try to access a tuple element that doesn't exist?

Compilation error

Runtime panic

Returns a default value

Wraps around to the first element

Question 43

In a graphics application where you need to represent RGBA color values, which type would be most appropriate?

Tuple: (u8, u8, u8, u8)

Array: [u8; 4]

Struct with named fields

Any of the above could work

Question 44

How do you convert between numeric types safely?

Using TryFrom and TryInto traits

Using the 'as' keyword

Using automatic conversion

Numeric conversion is always unsafe

Question 45

When processing a large dataset where you need to ensure no data loss during type conversions, what approach should you use?

Use TryFrom/TryInto and handle conversion errors

Use 'as' casting for performance

Use larger types to avoid overflow

Use unchecked conversions

Other Quiz Categories

JavaScript

47 quizzes

Basics

Variables & Data Types

Operators & Expressions

Python

29 quizzes

Introduction & Core Fundamentals

Data Types & Zero Values

Operators & Expressions

C++

26 quizzes

Basics

Variables & Data Types

Operators & Expression

Java

22 quizzes

Java Basics & JVM Fundamentals

Variables, Data Types & Type Casting

Operators & Expressions

Matlab

21 quizzes

Basics & Environment

Variables and Data Type

Arrays and Matric

TypeScript

19 quizzes

Introduction and Overview

Installation and Configuration

Basic Types and Type Annotations

SQL Database

15 quizzes

Foundations and Basics

Basic Query Selection

Filter, Sort, and Alias Essentials

PHP

15 quizzes

Syntax Building Blocks

Node Structure and Pointer Fundamentals

Singly Linked List

QUIZZES IN Rust

Cargo and Project Setup

40 comprehensive questions on Rust's package manager Cargo, covering project initialization, building, running, project structure, and dependency management — with 15 code examples demonstrating practical Cargo usage.

Variables and Mutability

40 comprehensive questions on Rust's variable system, covering let bindings, mut keyword, shadowing, type inference, and constants — with 12 code examples demonstrating practical variable usage patterns.

Data Types

Control Flow

45 comprehensive questions on Rust's control flow constructs, covering if expressions, loops, and control flow keywords — with 15 code examples demonstrating practical control flow usage.

Functions

40 questions covering function parameters, return values, expressions, diverging functions, and function scope in Rust.

Ownership

45 in-depth questions covering Rust's ownership system, move semantics, copy types, resource cleanup through Drop trait, precise drop timing, and ownership transfer patterns — with 12 code examples to solidify understanding.

Borrowing

45 in-depth questions covering Rust's borrowing system, immutable and mutable references, aliasing rules, reference scopes, and borrow checker validation — with 13 code examples to solidify understanding.

Lifetimes

40 in-depth questions covering Rust's lifetime system, lifetime annotations, elision rules, function signatures with lifetimes, struct references, and common lifetime errors — with 11 code examples to solidify understanding.

Strings

40 comprehensive questions on Rust's string types, covering String vs &str, UTF-8 behavior, slicing, mutating strings, and conversions — with 11 code examples demonstrating practical string handling patterns.

Collections

40 comprehensive questions on Rust's collection types, covering Vec, HashMap, VecDeque, iteration patterns, and capacity management — with 11 code examples demonstrating practical collection usage.

Slices

40 comprehensive questions on Rust's slice types, covering borrowed views, indexing, mutable slices, ranges, and slice methods — with 11 code examples demonstrating practical slice usage patterns.

Pattern Matching

40 comprehensive questions on Rust's pattern matching system, covering match expressions, destructuring, guards, wildcards, and enum matching — with 11 code examples demonstrating practical pattern matching techniques.

Enums

40 comprehensive questions on Rust's enum system, covering simple variants, data-carrying variants, enum matching, methods on enums, and Option/Result patterns — with 11 code examples demonstrating practical enum usage.

Struct

40 comprehensive questions on Rust's struct system, covering named fields, tuple structs, methods, associated functions, and field ownership — with 11 code examples demonstrating practical struct usage.

Modules

40 comprehensive questions on Rust's module system, covering module creation, visibility, imports, paths, and the use keyword — with 11 code examples demonstrating practical module organization patterns.

Traits

40 comprehensive questions on Rust's trait system, covering trait definitions, implementations, bounds, associated types, and trait objects — with 11 code examples demonstrating practical trait usage patterns.

Generic

40 comprehensive questions on Rust's generic programming system, covering generic functions, structs, enums, impl blocks, and monomorphization — with 11 code examples demonstrating practical generic usage patterns.

Iterators

Master Rust's powerful iterator system for efficient data processing and transformation

Closures

Master Rust's closure system for capturing environment variables and creating flexible function-like constructs

Error Handling

Master Rust's robust error handling system with Result, Option, and the ? operator for reliable code

File and I/O Operations

Master Rust's file system operations and I/O handling for robust data persistence and streaming

Smart Pointers

Master Rust's smart pointer types for automatic memory management and safe heap allocation

Concurrency

Master Rust's concurrency model with threads, channels, and synchronization primitives for safe parallel programming

Async Programming

Master asynchronous programming in Rust with futures, async/await, and concurrent execution patterns

Memory Management

Deep dive into Rust's ownership system, borrowing rules, and advanced memory management patterns for safe and efficient code

Macros

Master Rust's metaprogramming system with declarative and procedural macros for code generation and compile-time programming

Attributes

Master Rust's attribute system for conditional compilation, testing, documentation, and code generation

Testing

Master comprehensive testing strategies in Rust including unit tests, integration tests, documentation tests, and testing best practices

Crate Architecture

Master the design and organization of Rust crates including module systems, workspace management, dependency handling, and publishing strategies

Performance and Optimization

Master advanced performance techniques in Rust including profiling, benchmarking, memory optimization, and compiler optimizations

Rust Data Types Quiz

Question 1

Question 2

Question 3

Question 4

Question 5

Question 6

Question 7

Question 8

Question 9

Question 10

Question 11

Question 12

Question 13

Question 14

Question 15

Question 16

Question 17

Question 18

Question 19

Question 20

Question 21

Question 22

Question 23

Question 24

Question 25

Question 26

Question 27

Question 28

Question 29

Question 30

Question 31

Question 32

Question 33

Question 34

Question 35

Question 36

Question 37

Question 38

Question 39

Question 40

Question 41

Question 42

Question 43

Question 44

Question 45

About This Data Types Quiz

What You Will Practise

Other Quiz Categories

QUIZZES IN Rust

Cargo and Project Setup

Variables and Mutability

Data Types

Control Flow

Functions

Ownership

Borrowing

Lifetimes

Strings

Collections

Slices

Pattern Matching

Enums

Struct

Modules

Traits

Generic

Iterators

Closures

Error Handling

File and I/O Operations

Smart Pointers

Concurrency

Async Programming

Memory Management

Macros

Attributes

Testing

Crate Architecture

Performance and Optimization