Functions

Functions are a fundamental building block in Rust, as in any programming language. They allow you to encapsulate logic and reuse code, making your programs more modular and easier to understand. In this challenge, you will define and implement a series of simple functions that perform basic operations.

Your task

Your task is to define three functions:

add(a: i32, b: i32) -> i32 - This function should return the sum of a and b.
subtract(a: i32, b: i32) -> i32 - This function should return the difference between a and b.
multiply(a: i32, b: i32) -> i32 - This function should return the product of a and b.

You need to complete these functions so that they correctly perform the specified operations.

Example

let result = add(2, 3);
assert_eq!(result, 5);
 
let result = subtract(5, 3);
assert_eq!(result, 2);
 
let result = multiply(2, 3);
assert_eq!(result, 6);

Hints

You can define a function in Rust using the fn keyword followed by the function name, parameters in parentheses, and the return type.
Use the return keyword or just the last expression in the function body to return a value.
Make sure you use the pub keyword to make your functions public so they can be accessed from other modules.
Make sure your function signatures match the required signatures exactly.

Editor not available on Mobile!

In order to solve the challenge, please visit this page on a desktop computer.

Solutions

CB-42458

3 hours ago

2.35ms

81.30kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a+b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    a-b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {
    a*b
}

Photon

quantumxt

2 days ago

2.63ms

81.30kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

Derek

D-Rekk

7 days ago

2.94ms

81.30kb

pub fn add(a: i32, b: i32) -> i32 {
    a + b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

Spivur

12 days ago

2.46ms

81.30kb

pub fn add(a: i32, b: i32) -> i32 
{
    return a + b;// Step 1: implement addition
}
// Step 2:
pub fn subtract(a: i32, b: i32) -> i32
{
    return a - b;
}// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
// Step 3:
pub fn multiply(a: i32, b: i32) -> i32
{
    return a * b;
}// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.

Juanjo Algaz

JuanjoA

12 days ago

2.56ms

81.30kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.

cdcb52

21 days ago

2.16ms

81.30kb

pub fn add(a: i32, b: i32) -> i32 {
    let add = a + b;
    return add;
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    let subtract = a - b;
    return subtract;
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {
    let mult = a * b;
    return mult;
}

Umair Ziyan

umairziyan

21 days ago

2.65ms

81.30kb

pub fn add(a: i32, b: i32) -> i32 {
    a + b
}
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.

Robert

relia1

21 days ago

2.51ms

81.30kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

hooneun

21 days ago

2.46ms

85.88kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

herlock77

22 days ago

2.41ms

81.30kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a : i32, b : i32 ) -> i32 {
    a * b
}

nodbew

23 days ago

2.52ms

81.30kb

pub fn add(a: i32, b: i32) -> i32 { a + b }
pub fn subtract(a: i32, b: i32) -> i32 { a - b }
pub fn multiply(a: i32, b: i32) -> i32 { a * b }

Alienora

25 days ago

2.50ms

81.30kb

pub fn add(a: i32, b: i32) -> i32 {
    a+b
}
pub fn subtract(a: i32, b: i32) -> i32 {
    a-b
}
pub fn multiply(a: i32, b: i32) -> i32 {
    a*b
}

dcodes

a month ago

2.49ms

81.30kb

pub fn add(a: i32, b: i32) -> i32 {
    a + b
}
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

Andrey Doroschenko

dorosch

a month ago

2.37ms

81.30kb

pub fn add(a: i32, b: i32) -> i32 {
    a + b
}
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

Hong

tszhong0411

a month ago

2.22ms

81.30kb

pub fn add(a: i32, b: i32) -> i32 {
    a + b
}
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.

Jeremy Minton

JJMinton

a month ago

2.55ms

81.30kb

pub fn add(a: i32, b: i32) -> i32 {
    return a + b;
}
pub fn subtract(a: i32, b: i32) -> i32 {
    return a - b;
}
pub fn multiply(a: i32, b: i32) -> i32 {
    return a * b;
}

Gideon Bature

GideonBature

a month ago

2.49ms

81.30kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

Jaisurya

JaiSuryaPrabu

2 months ago

3.46ms

81.30kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    return a+b;
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a : i32, b : i32) -> i32 {
    return a-b;
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a:i32,b:i32) -> i32{
    return a*b;
}

Mrigesh patni

Mrigesh901

2 months ago

2.27ms

81.30kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    let sum = a+b;
    return sum;
}
pub fn subtract(a: i32, b: i32) -> i32 {
    let sum = a-b;
    return sum;
}
pub fn multiply(a: i32, b: i32) -> i32 {
    let sum = a*b;
    return sum;
}
fn main() {
    let result = add(2, 3);
    assert_eq!(result, 5);
    
    let result = subtract(5, 3);
    assert_eq!(result, 2);
    
    let result = multiply(2, 3);
    assert_eq!(result, 6);
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.

Hritul

Hritul2

2 months ago

3.02ms

81.30kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a+b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a:i32,b:i32)->i32{
    a-b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a:i32,b:i32)->i32{
    a*b
}

Rudolf Shenfeld

nerudxlf

3 months ago

2.19ms

85.88kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

Roman Istomin

istominrs

3 months ago

2.90ms

85.88kb

pub fn add(a: i32, b: i32) -> i32 {
    a + b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

Ozen

enzo-rma

3 months ago

2.38ms

81.30kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}