Modulo Calculator

Using the calculator is straightforward. You need two values: the dividend (the number being divided) and the divisor (the number you're dividing by). Enter both, then click calculate to see the remainder.

• Dividend (a): the number you want to divide
• Divisor (n): the number you're dividing by
• Result: the remainder left over after division

For example, enter 17 as the dividend and 5 as the divisor. The calculator returns 2, because 17 divided by 5 equals 3 with a remainder of 2. You can also use decimal inputs depending on what the tool supports, but modulo is most commonly applied to integers.

The modulo operation finds the remainder when one integer is divided by another. If you divide 10 by 3, you get 3 with 1 left over. That leftover, 1, is the result of 10 mod 3.

It's different from regular division because you're not interested in the quotient. You only care about what's left behind after as many whole divisions as possible have been taken out. Think of it like cutting a rope into equal pieces and measuring the scrap at the end.

The notation varies depending on context. In math, you'll often see it written as a mod n. In most programming languages, the percent sign is used instead: a % n. Both mean the same thing: divide a by n and give me the remainder.

The formula for modulo comes directly from the division algorithm. Given integers a (dividend) and n (divisor, where n ≠ 0), the remainder r is defined as:

a = n × q + r

Where q is the quotient (the whole number result of division) and r is the remainder such that 0 ≤ r < n for positive values. So to find r manually: divide a by n, take the floor of that result to get q, then multiply q by n and subtract from a.

For example, with a = 23 and n = 7: 23 ÷ 7 ≈ 3.28, so q = 3. Then r = 23 − (7 × 3) = 23 − 21 = 2. That means 23 mod 7 = 2.

Modular arithmetic is a system where numbers wrap around after reaching a certain value, called the modulus. Think of a clock: after 12, you go back to 1, not 13. That wrapping behavior is exactly what modular arithmetic describes.

A modular arithmetic calculator lets you perform addition, subtraction, multiplication, and sometimes exponentiation under a given modulus. Instead of computing a raw result, you compute the result and then reduce it using mod. It's used heavily in cryptography, computer science, and number theory.

The notation a ≡ b (mod n) means that a and b leave the same remainder when divided by n. They're said to be congruent modulo n.

Doing modulo by hand isn't complicated once you have a clear process. Here are the steps:

1. Identify a and n. Know your dividend and divisor.
2. Divide a by n. Get the decimal result.
3. Take the floor. Round down to the nearest whole number. This is your quotient q.
4. Multiply q by n. Find q × n.
5. Subtract from a. r = a − (q × n). That's your remainder.

Let's walk through a full example: 58 mod 9.

1. a = 58, n = 9
2. 58 ÷ 9 = 6.444...
3. Floor(6.444) = 6, so q = 6
4. 6 × 9 = 54
5. 58 − 54 = 4

Result: 58 mod 9 = 4. You can verify: 9 × 6 = 54, and 54 + 4 = 58. Checks out.

Finding a remainder is the entire point of the modulo operation. It tells you what's left after dividing as evenly as possible. This is useful in a surprising number of everyday situations: splitting things into equal groups, checking divisibility, cycling through arrays in code, and more.

The key is understanding what the remainder actually represents. If you have 29 items and want to split them into groups of 6, the modulo tells you how many items don't fit into a complete group. 29 mod 6 = 5, so 5 items are left over after forming 4 complete groups of 6.

Congruence is the formal language of modular arithmetic. Two numbers are congruent modulo n if they have the same remainder when divided by n. This idea is foundational in number theory and has real practical implications in areas like cryptography and hashing.

Modular equations take this further by asking: given a relationship between numbers under a modulus, what values satisfy it? These equations look different from regular algebra, but many of the same instincts apply once you understand the rules of the system.

A handful of worked examples shows just how flexible modulo is across different number types and scenarios.

Notice the row where the dividend is smaller than the divisor (7 mod 20). The quotient is 0 and the full dividend becomes the remainder. And the negative example follows the floor-division convention, giving a positive result as expected in standard mathematical modulo.

Modulo is everywhere in software development. Once you start looking for it, you'll find it in almost every non-trivial codebase.

• Even/odd check: If n % 2 == 0, the number is even. That's probably the most common use of modulo in code.
• Cycling through arrays: Use index % array.length to wrap around to the start when you reach the end. Useful for carousels, round-robin scheduling, and ring buffers.
• Hash tables: Hash functions often use modulo to map a computed hash value into a fixed-size array: hash(key) % tableSize.
• Clock arithmetic in time: Converting seconds to hours, minutes, and seconds requires modulo. 3661 seconds: 3661 % 60 = 1 second, then floor(3661 / 60) % 60 = 1 minute, and so on.
• Cryptography: RSA and other public-key systems rely heavily on modular exponentiation. Without modulo, modern encryption wouldn't work.
• Checksums and parity bits: Error-detection schemes use modular arithmetic to verify data integrity.

It's one of those operators that looks simple but punches well above its weight in terms of how much real-world work it does.

In pure math, modular arithmetic is a core tool in number theory and abstract algebra. It's not just a curiosity; it's foundational to some of the most important results in mathematics.

Divisibility tests are based on modular arithmetic. The rule that a number is divisible by 9 if its digits sum to a multiple of 9 comes directly from the fact that 10 ≡ 1 (mod 9), so each digit's place value reduces to 1 under that modulus.

Fermat's Little Theorem states that if p is prime and a is not divisible by p, then a^(p−1) ≡ 1 (mod p). This result is used in primality testing and is a building block for RSA encryption.

The Chinese Remainder Theorem lets you solve systems of simultaneous congruences under different moduli, provided those moduli are coprime. It's a powerful result with applications in signal processing and computer arithmetic.

Modular arithmetic also appears in group theory. The integers mod n under addition form a cyclic group, written Z/nZ. These structures are studied in abstract algebra and connect modular arithmetic to much broader mathematical frameworks.

Beyond the theory, modular arithmetic shows up in calendar calculations (figuring out what day of the week a date falls on), music theory (the 12-tone scale wraps around in a way that's naturally modular), and competitive math problems where large numbers need to be simplified quickly. It's a genuinely versatile concept that rewards getting comfortable with.