**1. Overview**

Performing basic arithmetic operations is a fundamental skill in almost all programming languages.

In this tutorial, we’ll explore the essentials of computing the quotient and remainder in Kotlin.

## 2. Introduction to the Problem

Computing quotient and remainder isn’t a challenge for us. We’ll first address how to compute these values.

As the quotient and the remainder are two values, we’ll discuss how to get these values in one shot by creating a Kotlin function. Kotlin offers many excellent features that allow us to write idiomatic code. So, we’ll try to improve our function using some Kotlin features.

For simplicity, we’ll use integers as examples in this tutorial.

## 3. Using the ‘/’ and ‘%’ Operators

In Kotlin, computing the quotient and remainder is straightforward, thanks to** the division operator ‘/’ and the modulus operator ‘%’:**

```
val quotient1 = 42 / 4
val reminder1 = 42 % 4
assertEquals(10, quotient1)
assertEquals(2, reminder1)
val quotient2 = -42 / 4
val reminder2 = -42 % 4
assertEquals(-10, quotient2)
assertEquals(-2, reminder2)
val quotient3 = -42 / 2
val reminder3 = -42 % 2
assertEquals(-21, quotient3)
assertEquals(0, reminder3)
```

As the example above shows, we can compute the quotient and remainder in this way:

- Quotient = Dividend / Divisor
- Remainder = Dividend % Divisor

## 4. Creating a Function to Return the Quotient and the Remainder

Now that we understand how to compute the quotient and remainder using the ‘/’ and the ‘%’ operators, let’s create a function so that we can get the two values in a single function call:

```
fun getQuotientAndReminder(dividend: Int, divisor: Int): Pair<Int, Int> {
return dividend / divisor to dividend % divisor
}
```

As we can see, **to have a function return multiple values, we make the function return a ***Pair* object.

Next, let’s verify whether the function works as expected:

```
getQuotientAndReminder(42, 4).apply {
assertEquals(10, first)
assertEquals(2, second)
}
getQuotientAndReminder(-42, 4).apply {
assertEquals(-10, first)
assertEquals(-2, second)
}
getQuotientAndReminder(-42, 2).apply {
assertEquals(-21, first)
assertEquals(0, second)
}
```

The test passes when we give it a run. However, our function doesn’t handle the “zero as the divisor” case. For instance, let’s pass *0* as the divisor to the function:

`getQuotientAndReminder(42, 0)`

We’ll get an *ArithmeticException:*

`java.lang.ArithmeticException: / by zero`

Let’s say we’d like to handle this case and throw an *IllegalArgumentException* with a customized message when the divisor is zero. All we need to do is **add a ***require*() call to the function:

```
fun getQuotientAndReminder(dividend: Int, divisor: Int): Pair<Int, Int> {
require(divisor != 0) { "The divisor must not be zero" }
return dividend / divisor to dividend % divisor
}
```

Now, we’ll get the expected exception when we pass zero as the divisor to the function:

```
assertThrows<IllegalArgumentException> {
getQuotientAndReminder(42, 0)
}.also { assertEquals("The divisor must not be zero", it.message) }
```

## 5. Creating an Extension Function

The *getQuotientAndReminder()* function does the job. However, as we code and call this function, we must first type the function name and then pass the dividend and the divisor arguments to it.

A more natural and fluent way to call a function to compute the quotient and the remainder would be, for example, *42 dividedBy 4*.

Next, let’s see if how this can be achieved:

```
infix fun Int.dividedBy(divisor: Int): Pair<Int, Int> {
require(divisor != 0) { "The divisor must not be zero" }
return this / divisor to this % divisor
}
```

First, **we make ***dividedBy()* as an extension function of *Int*, so all *Int* can call it as a member function, for example, *42.dividedBy(2).* Then, **we add ***infix* keyword to call the function without typing the period and brackets.

Finally, let’s compare the code of two function calls:

```
val (quotient, reminder) = 42 dividedBy 4
val (quotient, reminder) = getQuotientAndReminder(42, 4)
```

As we can see, the *dividedBy()* function call is easier to read and natural to type. It’s worth noting that **we’ve used Kotlin’s deconstructing declaration to assign the two variables in one line**.

**6. Conclusion**

In this article, first, we explored computing the quotient and remainder using the division and the modulus operators. Then, we created a function to return a *Pair* object so that we can obtain these two values in one single function call.

Finally, we polished our function by making it an *infix* extension function.

As always, the complete source code for the examples is available over on GitHub.