30 Rust Coding Challenges for Entry-Level to Senior Developers

The traditional first program to verify a working setup.

fn main() {
    println!("Hello, World!");
}

A basic test of loops and vector manipulation.

fn sum(numbers: &Vec) -> i32 {
    let mut total = 0;
    for &num in numbers {
        total += num;
    }
    total
}

A simple test of string manipulation.

fn reverse(s: &str) -> String {
    s.chars().rev().collect()
}

A fundamental algorithm using a simple loop.

fn largest(list: &[i32]) -> i32 {
    let mut largest = list[0];
    for &item in list {
        if item > largest {
            largest = item;
        }
    }
    largest
}

Tests string manipulation and comparison logic.

fn is_palindrome(s: &str) -> bool {
    let reversed: String = s.chars().rev().collect();
    s == reversed
}

The classic test of basic conditional logic and loops.

fn fizzbuzz(n: u32) {
    for i in 1..=n {
        if i % 15 == 0 {
            println!("FizzBuzz");
        } else if i % 3 == 0 {
            println!("Fizz");
        } else if i % 5 == 0 {
            println!("Buzz");
        } else {
            println!("{}", i);
        }
    }
}

Introduces custom types and data organization.

struct Person {
    name: String,
    age: u32,
}

A simple function to demonstrate optional values.

fn find_user(id: u32) -> Option {
    if id == 1 {
        Some("Alice".to_string())
    } else {
        None
    }
}

A basic loop to demonstrate syntax.

fn print_numbers() {
    for i in 1..=10 {
        println!("{}", i);
    }
}

Tests basic conditional logic.

fn check_number(n: i32) {
    if n > 0 {
        println!("Positive");
    } else if n < 0 {
        println!("Negative");
    } else {
        println!("Zero");
    }
}

Use a `HashMap` to count the frequency of words in a text.

use std::collections::HashMap;

fn word_count(text: &str) -> HashMap {
    let mut map = HashMap::new();
    for word in text.split_whitespace() {
        let count = map.entry(word.to_string()).or_insert(0);
        *count += 1;
    }
    map
}

A simple trait for a `Shape` with an `area` method.

trait Shape {
    fn area(&self) -> f64;
}

struct Circle {
    radius: f64,
}

impl Shape for Circle {
    fn area(&self) -> f64 {
        std::f64::consts::PI * self.radius * self.radius
    }
}

Convert Rust structs to and from JSON using the `serde` crate.

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct User {
    name: String,
    age: u32,
}

A common interview question that can be solved with a `HashMap`.

use std::collections::HashMap;

fn first_non_repeating_character(s: &str) -> Option {
    let mut counts = HashMap::new();
    for c in s.chars() {
        *counts.entry(c).or_insert(0) += 1;
    }
    for c in s.chars() {
        if counts[&c] == 1 {
            return Some(c);
        }
    }
    None
}

A simple generic function that takes a slice of any type that implements the `Display` trait.

use std::fmt::Display;

fn print_slice(slice: &[T]) {
    for item in slice {
        println!("{}", item);
    }
}

A simple example of error handling with `Result`.

fn divide(a: f64, b: f64) -> Result {
    if b == 0.0 {
        Err("Cannot divide by zero".to_string())
    } else {
        Ok(a / b)
    }
}

A simple example of a closure.

fn main() {
    let add_one = |x| x + 1;
    println!("{}", add_one(1));
}

A simple command-line argument parser.

use std::env;

fn main() {
    let args: Vec = env::args().collect();
    println!("{:?}", args);
}

A simple example of reading and writing to a file.

use std::fs;

fn main() -> std::io::Result<()> {
    fs::write("foo.txt", "Hello, world!")?;
    let contents = fs::read_to_string("foo.txt")?;
    println!("{}", contents);
    Ok(())
}

A simple implementation of a linked list.

enum List {
    Cons(i32, Box),
    Nil,
}

A thread-safe counter using `Arc>`.

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Result: {}", *counter.lock().unwrap());
}

A simple web server with `tokio`.

use tokio::net::{TcpListener, TcpStream};
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() -> Result<(), Box> {
    let listener = TcpListener::bind("127.0.0.1:8080").await?;

    loop {
        let (mut socket, _) = listener.accept().await?;

        tokio::spawn(async move {
            // ...
        });
    }
}

A simple memory allocator.

use std::alloc::{GlobalAlloc, Layout, System};

struct MyAllocator;

unsafe impl GlobalAlloc for MyAllocator {
    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
        System.alloc(layout)
    }

    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
        System.dealloc(ptr, layout)
    }
}

#[global_allocator]
static GLOBAL: MyAllocator = MyAllocator;

A simple macro.

macro_rules! five {
    () => {
        5
    };
}

fn main() {
    println!("{}", five!());
}

A simple async runtime.

// This is a complex task that would require a lot of code.
// A full implementation would be too long for this format.

A simple example of using unsafe Rust to interact with C code.

extern "C" {
    fn abs(input: i32) -> i32;
}

fn main() {
    unsafe {
        println!("Absolute value of -3 is {}", abs(-3));
    }
}

A simple concurrent queue.

use std::collections::VecDeque;
use std::sync::{Arc, Condvar, Mutex};

struct ConcurrentQueue {
    inner: Arc<(Mutex>, Condvar)>,
}

A simple key-value store.

use std::collections::HashMap;

struct KvStore {
    map: HashMap,
}

impl KvStore {
    fn new() -> KvStore {
        KvStore {
            map: HashMap::new(),
        }
    }

    fn set(&mut self, key: String, value: String) {
        self.map.insert(key, value);
    }

    fn get(&self, key: &str) -> Option<&String> {
        self.map.get(key)
    }
}

A simple state machine.

enum State {
    Start,
    Running,
    Stop,
}

struct StateMachine {
    state: State,
}

impl StateMachine {
    fn new() -> StateMachine {
        StateMachine {
            state: State::Start,
        }
    }

    fn transition(&mut self, new_state: State) {
        self.state = new_state;
    }
}

A simple build script for a crate.

// In build.rs
fn main() {
    println!("cargo:rerun-if-changed=src/hello.c");
    cc::Build::new().file("src/hello.c").compile("hello");
}