**TL ; DR:**

The

`Math.floor()`

function returns the largest integer less than or equal to a given number:`System.out.println(Math.floor(3.9)); // Output: 3 System.out.println(Math.floor(5.2)); // Output: 5 System.out.println(Math.floor(7)); // Output: 7`

We can use this function if we want to compute the

**integral part**of some division (**quotient**):`int a = 3; int b = 7; System.out.println(Math.floor(20 / a)); // Output: 6 System.out.println(Math.floor(b / a)); // Output: 2`

**Full lesson:**

Remember how we first learn about the division of two integer numbers in primary school?

The **quotient** is the number of times a division is completed fully, while the **remainder** is the amount left that doesn't entirely go into the divisor.

Here are some examples:

```
10 / 2 = quotient 5, remainder 0
15 / 4 = quotient 3, remainder 3
20 / 3 = quotient 6, remainder 2
```

**Floor division**

Floor division (`//`

) is a normal division operation except that it returns the integral part of the result (the **quotient**):

```
print(10 // 2) # Output: 5
print(15 // 4) # Output: 3
print(20 // 3) # Output: 6
```

It can also be used with variables:

```
a = 3
b = 7
print(20 // a) # Output: 6
print(b // a) # Output: 2
```

**Modulo**

The modulo operator (`%`

) calculates the **remainder** of dividing two values:

```
print(10 % 2) # Output: 0
print(15 % 4) # Output: 3
print(20 % 3) # Output: 2
# Can be used with variables:
a = 2
b = 4
print(b % a) # Output: 0
print(11 % b) # Output: 3
```

**Quotient and remainder**

In programming, we combine both these concepts to get the quotient and remainder of some divison:

```
# Let's divide 26 by 3:
quotient = 26 // 3
remainder = 26 % 3
print(quotient) # Output: 8
print(remainder) # Output: 2
```

**Assignment**

Follow the Coding Tutorial and let's practice with quotient and remainder!

**Hint**

Look at the examples above if you get stuck.

In this lesson, we will explore the concept of floor division in Java. Floor division is a mathematical operation that returns the largest integer less than or equal to the result of a division. This is particularly useful in scenarios where we need to work with whole numbers, such as in financial calculations, indexing, and loop iterations.

Before diving into floor division, it's important to understand the basic concepts of division. When we divide two numbers, we get a quotient and a remainder. The quotient is the number of times the divisor fits into the dividend, while the remainder is what's left over.

For example:

```
10 / 2 = quotient 5, remainder 0
15 / 4 = quotient 3, remainder 3
20 / 3 = quotient 6, remainder 2
```

Floor division focuses on the quotient, discarding any remainder.

In Java, we can use the `Math.floor()`

function to perform floor division. This function returns the largest integer less than or equal to a given number. Let's see how it works:

```
System.out.println(Math.floor(3.9)); // Output: 3
System.out.println(Math.floor(5.2)); // Output: 5
System.out.println(Math.floor(7)); // Output: 7
```

We can also use this function to compute the integral part of a division:

```
int a = 3;
int b = 7;
System.out.println(Math.floor(20 / a)); // Output: 6
System.out.println(Math.floor(b / a)); // Output: 2
```

Let's look at some examples to understand how floor division can be applied in different contexts:

```
public class FloorDivisionExample {
public static void main(String[] args) {
int a = 3;
int b = 7;
// Example 1: Simple floor division
System.out.println(Math.floor(20 / a)); // Output: 6
// Example 2: Floor division with variables
System.out.println(Math.floor(b / a)); // Output: 2
// Example 3: Floor division in a loop
for (int i = 1; i <= 10; i++) {
System.out.println("Floor division of " + i + " by 3: " + Math.floor(i / 3));
}
}
}
```

When using floor division, it's important to be aware of common mistakes:

- Using floating-point numbers without converting them to integers can lead to unexpected results.
- Forgetting to handle edge cases, such as division by zero.

Best practices include:

- Always validate input values before performing division.
- Use integer division when working with whole numbers to avoid precision issues.

For more advanced use cases, you can combine floor division with other mathematical operations. For example, you can use it to implement custom rounding functions or to optimize algorithms that require integer results.

```
public class AdvancedFloorDivision {
public static void main(String[] args) {
double value = 5.75;
int roundedDown = (int) Math.floor(value);
System.out.println("Rounded down: " + roundedDown); // Output: 5
// Custom rounding function
int customRounded = (int) (Math.floor(value + 0.5));
System.out.println("Custom rounded: " + customRounded); // Output: 6
}
}
```

Here is a complete example demonstrating the use of floor division in Java:

```
public class FloorDivision {
public static void main(String[] args) {
int dividend = 26;
int divisor = 3;
int quotient = (int) Math.floor((double) dividend / divisor);
int remainder = dividend % divisor;
System.out.println("Quotient: " + quotient); // Output: 8
System.out.println("Remainder: " + remainder); // Output: 2
}
}
```

When debugging code that involves floor division, consider the following tips:

- Print intermediate results to verify calculations.
- Use assertions to check for expected outcomes.

For testing, you can write unit tests to validate the behavior of your floor division logic:

```
import static org.junit.Assert.assertEquals;
import org.junit.Test;
public class FloorDivisionTest {
@Test
public void testFloorDivision() {
assertEquals(6, Math.floor(20 / 3));
assertEquals(2, Math.floor(7 / 3));
}
}
```

When approaching problems related to floor division, consider the following strategies:

- Break down the problem into smaller parts and solve each part individually.
- Use diagrams or visual aids to understand the division process.
- Practice with different examples to gain a deeper understanding.

In this lesson, we covered the concept of floor division in Java. We explored its significance, common use cases, and best practices. By mastering floor division, you can write more efficient and accurate code for various applications. Keep practicing and exploring further to deepen your understanding.

For further reading and practice problems, consider the following resources: