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

KuTaKe

kuttakke

a day ago

3.04ms

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
}

Yossa Bourne

terminox

a day ago

3.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.
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
}

qiyuan711

a day ago

3.47ms

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
}

apst

a day ago

4.53ms

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
}

Jan Willems

a day ago

2.51ms

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.

Nicky Thorne

nickythorne

a day ago

2.78ms

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
}

Sandeep chauhan

ryzen-xp

a day ago

3.00ms

81.28kb

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

Derteq

a day ago

2.89ms

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
}

chuyuanlinzi

2 days ago

5.48ms

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
}

Philip Mercer

DV-13

2 days ago

3.03ms

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
}

tinthid

2 days ago

5.09ms

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
}

yoakemae

2 days ago

2.81ms

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

martin-unit

2 days ago

3.56ms

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
}

Neil Rayu

Neil-Rayu

2 days ago

2.82ms

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

RonaldoArayadev

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

Reda Bouaida

3ok

2 days ago

2.68ms

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
}

leenalmajz

2 days ago

2.73ms

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
}

Elizabeth Doughty

Thymelizabeth

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

Hudson

dalprahcd

3 days ago

3.22ms

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
}

devarajang

3 days ago

2.80ms

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
}

Jan

jeypiti

4 days ago

2.80ms

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
}

s.konishi

konishu

4 days ago

3.93ms

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

nichideropa

4 days ago

2.75ms

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
}

Pascal Dietrich

Cameo007

4 days ago

3.23ms

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
}

aleksey-vareto

4 days ago

2.98ms

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
}

akshayabhattarai

4 days ago

3.09ms

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.

madeinheaven91

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

oDqnger

4 days ago

3.41ms

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
}

matsuyama-k1

5 days ago

5.70ms

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

Takuro Niitsuma

otakumesi

5 days ago

2.95ms

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
}

Kohei Matsubara

matsuby

5 days ago

3.12ms

81.28kb

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

kada-s

sy34

5 days ago

3.16ms

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

Ankeet Parikh

ankeetparikh

5 days ago

2.68ms

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
}

0xsmarter

5 days ago

2.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
}

0xsmarter

5 days ago

3.14ms

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
}

aidan1magee

5 days ago

3.69ms

85.87kb

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
}

maxvi

5 days ago

3.49ms

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
}

Rayen Benbetaieb

P0TER19

6 days ago

2.76ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    let sum: i32 = a + b;
    return sum;
}
// 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 sub: i32 = a - b;
    return sub;
}
// 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 mul: i32 = a * b;
    return mul;
}

Ugochukwu Paul

ugochukwudev

6 days ago

3.51ms

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
}

Rafael Lucas

rafaellucasprogm

6 days ago

3.35ms

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
}

Walquer Xavier Valles Ruiz

WalquerX

6 days ago

3.64ms

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
}

koslowskio

6 days ago

2.73ms

81.28kb

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

Rocky.C

cloki0610

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

Denis SOURON

Brack0

7 days ago

4.57ms

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
}

Samori Gorse

shinuza

7 days ago

2.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 {
    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.

tsuchiya-d

tsucchinoko

7 days ago

2.91ms

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
}

Sabin Howard

whitwulf

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

risemacro

7 days ago

2.92ms

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
}

Thitiworada

Kobeieii

7 days ago

5.54ms

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
}

Kei Kori

2k0ri

8 days ago

3.35ms

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
}