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

madkrell

2 hours ago

3.63ms

81.28kb

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

Yuma Nur Alfath

yumanuralfath

5 hours ago

3.00ms

81.28kb

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 
}

CASEA

Zuttergutao

12 hours ago

2.99ms

81.28kb

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
}

tagucci

17 hours ago

2.93ms

81.28kb

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
}

YCH931

a day ago

3.60ms

81.28kb

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
}

wassie1256

a day ago

3.77ms

81.28kb

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;
}

jordan-betterman

2 days ago

3.10ms

81.28kb

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;
}

Kağan

medarduss

2 days ago

2.81ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
   a+b // Step 1: implement addition
}
// Step 2:
pub fn subtract(a: i32, b: i32) -> i32{
    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{
    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.

Facundo Hernandez

facuhernandez99

2 days ago

2.90ms

81.28kb

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.
// 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 subtract (a:i32, b:i32) -> i32 {
    a-b
}
pub fn multiply (a:i32, b:i32) -> i32 {
    a*b
}

Hung Dinh

nhdinh

3 days ago

4.06ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
pub fn subtract(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.
pub fn multiply(a: i32, b: i32) -> i32 {
    a*b
}

Dario d'Abate

DariodAbate

3 days ago

3.66ms

81.28kb

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
}

Lucas Deprit

lucasdeprit

3 days ago

2.87ms

81.28kb

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.

skrzypson

3 days ago

5.83ms

81.28kb

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
}

skrzypson

3 days ago

3.12ms

81.28kb

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
}

amaneru

7ma8no9

3 days ago

3.74ms

81.28kb

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
}

Esteban Pérez

lep511

4 days ago

6.83ms

81.28kb

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.

Madhankumar Anandan

amkumar072

4 days ago

9.65ms

81.28kb

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
}

Pranav Garg

PranavGarg01

4 days ago

2.88ms

81.28kb

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
}

Muhammad Haikal

heykall

4 days ago

3.42ms

81.28kb

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
}

tady (GitHub)

tadyjp

5 days ago

4.30ms

81.28kb

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
}

Ghostttty

6 days ago

2.77ms

81.28kb

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(lhs: i32, rhs: i32) -> i32 {
    lhs - rhs
}
// 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(lhs: i32, rhs: i32) -> i32 {
    lhs * rhs
}

zawwwu

6 days ago

3.19ms

81.28kb

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
}

AKA.MoneyTaker

M4Bo2

7 days ago

3.16ms

81.28kb

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 {
    // Step 1: implement addition
    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 {
    // Step 1: implement addition
    a*b
}

SilentCanon

silentcanon

7 days ago

2.82ms

81.28kb

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
}

Chris Anatalio

anataliocs

7 days ago

5.70ms

81.28kb

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.

Chris Blake

chrisb92

7 days ago

3.03ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    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;
}

pagyeman

7 days ago

11.32ms

81.28kb

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
}

Faisal Ahmed

Faisal-8898

8 days ago

3.13ms

81.28kb

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
}

Nelly

nellyisanon

8 days ago

4.45ms

81.28kb

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
}

JackY

Scorpio24

9 days ago

3.45ms

81.28kb

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
}

AnKarl

Zythophilus

9 days ago

2.90ms

81.28kb

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
}

Heatiche Mix

HeaticheTakachi

9 days ago

2.72ms

81.28kb

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
}

buu

bushuai

10 days ago

3.50ms

81.28kb

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
}

Likith-LVSHD

10 days ago

4.14ms

81.28kb

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.
// 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 subtract(a: i32, b: i32) -> i32 {
    a-b
}
pub fn multiply(a: i32, b: i32) -> i32 {
    a*b
}

Yi Hao

leongyihao

10 days ago

2.92ms

81.28kb

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
}

Éric Villani

TheTrueCaligari

10 days ago

2.96ms

81.28kb

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 {
    // Step 1: implement addition
    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 {
    // Step 1: implement addition
    a*b
}

Sathit Junthong

famesensor

10 days ago

2.89ms

81.28kb

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
}

fyroostr

10 days ago

2.83ms

81.28kb

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
}

Justin Lee

juslee

10 days ago

2.82ms

81.28kb

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
}

PixelForg

11 days ago

2.78ms

81.28kb

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
}

kustrun

11 days ago

2.96ms

81.28kb

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
}

Lê Minh Quân

aleister1102

11 days ago

3.13ms

81.28kb

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
}

Muhammad Najib Bala

NAJIB-B

11 days ago

8.61ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
pub fn subtract(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a - b
}
pub fn multiply(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.
// 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.

gmvar

12 days ago

3.83ms

81.28kb

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
}

DevBrain888

12 days ago

3.03ms

81.28kb

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.

wiasliaw

12 days ago

3.77ms

81.28kb

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
}

Ayushman Rathore

Spartan09

12 days ago

8.86ms

81.28kb

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
}

Deaddy3

12 days ago

3.07ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
// Step 2:
pub fn subtract(a: i32, b: i32) -> i32 {
    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 {
    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.

Aggelos Avgerinos

avgerin0s

13 days ago

3.06ms

81.28kb

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;
}

TheEquationLabs

13 days ago

4.22ms

81.28kb

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.